//////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////

double phi()
{
  return (1 + Math.sqrt(5))/2;
}

void arch(int x, int y, int radio, double angle_ini, double angle_end)
{
  double diff = (angle_ini < angle_end) ? 0.3 : -0.3;
  
  for(double a=angle_ini; a<angle_end; a = a + diff)
  {
    double h = radio * Math.sin(a);
    double k = Math.sqrt(radio*radio - h*h);
    
    double px = x + k;
    double py = y + h;
      
    point((int)px, (int)py);
  }
}

//////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////

class Point
{
  private int x;
  private int y;
  
  public Point()
  {
    this(0, 0);
  }
  
  public Point(int _x, int _y)
  {
    setX(_x);
    setY(_y);
  }
  
  public void setX(int value)
  {
    x = value;
  }

  public void setY(int value)
  {
    y = value;
  }
  
  public int getX()
  {
      return x;
  }

  public int getY()
  {
      return y;
  }
}

//////////////////////////////////////////////////////////////////

class Dimension
{
  private int width;
  private int height;
  
  public Dimension()
  {
    this(0, 0);
  }
  
  public Dimension(int _w, int _h)
  {
    setWidth(_w);
    setHeight(_h);
  }
  
  public void setWidth(int value)
  {
    width = value;
  }

  public void setHeight(int value)
  {
    height = value;
  }
  
  public int getWidth()
  {
      return width;
  }

  public int getHeight()
  {
      return height;
  }
  
  public String toString()
  {
    return "Dimension: width=" + getWidth() + ", height=" + getHeight();
  }
}

//////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////

class GoldenRectangle
{
  ////////////////////////////////////////////////////////////////

  private int x;
  private int y;
  private int width;
  private int height;
  private int direction;
  private int depth;
  private GoldenRectangle inner;
  
  public final static int north = 1;
  public final static int west  = 2;
  public final static int south = 3;
  public final static int east  = 4;
  
  ////////////////////////////////////////////////////////////////

  public GoldenRectangle(int _d, int _x, int _y, int _w, int _h, int _depth)
  {
    direction = _d;
    x = _x;
    y = _y;
    this.width = _w;
    this.height = _h;
    depth = _depth;
    
    if (depth < max_depth)
    {
      inner = new GoldenRectangle(getNextDirection(), 
                                  getInnerStartPoint().getX(), 
                                  getInnerStartPoint().getY(), 
                                  getInnerDimension().getWidth(),
                                  getInnerDimension().getHeight(),
                                  _depth + 1);                                  
    }
  }
  
  ////////////////////////////////////////////////////////////////

  private Point getInnerStartPoint()
  {
    switch(direction)
    {
      case north:  return new Point(x, y);
      case west:   return new Point(x, y);
      case south:  return new Point(x, y + this.height - getInnerDimension(direction).getHeight());
      case east:   return new Point(x + this.width - getInnerDimension(direction).getWidth(), y);
    }

    return null;
  }

  ////////////////////////////////////////////////////////////////

  private Dimension getInnerDimension()
  {
    return getInnerDimension(direction);
  }
  
  private Dimension getInnerDimension(int _direction)
  {
    Dimension d = null;
    
    switch(_direction)
    {
      case north:  return new Dimension(this.width, (int)(this.height - this.height / phi()));
      case west:   return new Dimension((int)(this.width - this.width / phi()), this.height);
      case south:  return new Dimension(this.width, (int)(this.height - this.height / phi()));
      case east:   return new Dimension((int)(this.width - this.width / phi()), this.height);
    }

    return null;
  }

  ////////////////////////////////////////////////////////////////

  private int getNextDirection()
  {
    return (direction + 1 > 4) ? 1 : direction + 1;
  }
  
  ////////////////////////////////////////////////////////////////

  public void draw(int drawDepth, boolean drawLines, boolean drawSpiral)
  {
    if(drawLines)
    {
      stroke(91, 91, 91);
      rectMode(CORNER);
      rect(x, y, this.width, this.height);
    }
    
    if(drawSpiral && depth > 0)
    {
      double angle_ini = (270 + 90 * (depth - 1))%360;
      double angle_end = (90 * (depth - 1))%360;
      
      stroke(255, 126, 91);
      arch(x, y, this.width, angle_ini * Math.PI / 180, angle_end * Math.PI / 180);
    }
    
    if(inner != null && drawDepth > depth)
      inner.draw(drawDepth, drawLines, drawSpiral);
  }

  ////////////////////////////////////////////////////////////////
}

//////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////

int max_depth = 10;
int curr_depth = 0;
boolean drawLines = true;
boolean drawSpiral = false;

GoldenRectangle gr = null;

void setup() 
{  
  ////////////////////////////////////////////////////////////////

  int recWidth  = width;
  int recHeight = (int)(width * phi());

  ////////////////////////////////////////////////////////////////

  noLoop();

  gr = new GoldenRectangle(GoldenRectangle.north, 0, 0, recWidth, recHeight, 0);

  redraw();

  ////////////////////////////////////////////////////////////////
}

void keyPressed()
{
  if(key == '5')
  {
    curr_depth ++;

    if(curr_depth == max_depth)
      curr_depth = 0;
      
    redraw();
  }
  
  if(key == '*')
  {
    drawLines = !drawLines;
    redraw();
  }
  
  if(key == '#')
  {
    drawSpiral = !drawSpiral;
    redraw();
  }
}

void draw()
{
  background(255, 255, 255);
  
  if (gr != null)
    gr.draw(curr_depth, drawLines, drawSpiral);
}

//////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////