class Node
{
  Color myColor;
  ArrayList children;
  Node parent;
  boolean end;
  boolean visited;
  Blob myBlob;

  Node()
  {
    myBlob = new Blob(width, height);
    myColor = myBlob.getColor();
    children = new ArrayList();
    end = false;
    visited = false;
  }

  Blob getBlob()
  {
    return myBlob; 
  }

  void setChildren( ArrayList nodes )
  { 
    for(int i =0; i<nodes.size(); ++i)
    {
      children.add((Node)nodes.get(i));
    }
  }

  void setParent( Node node )
  {
    parent = node;
  }

  Node getParent()
  {
    return parent;
  }

  ArrayList getChildren()
  {
    return children;
  }

  Color getColor()
  {
    return myColor;
  }
  void setEnd()
  {
    end = true;
  }

  void setVisited()
  {
    visited = true; 
  }

  boolean hasVisited()
  {
    return visited;
  }

  boolean isEnd()
  {
    return end;
  }

  void render()
  {
    myBlob.render();
  }

  void update()
  {
    myBlob.update(); 
  }

  void renderAt(int x, int y)
  {
    if(visited)
      myColor.a = 255;
    else
      myColor.a = 50;
    strokeWeight(1);
    if(!end)
      fill(myColor.r, myColor.g, myColor.b, 150);//myColor.a);
    else
    {
      strokeWeight(5);
      fill(255, 0,0, 150);//myColor.a);
    }
    ellipse(x, y, 11, 11); 
    strokeWeight(1);
  }
  
  void renderAtCurrent(int x, int y)
  {
    if(visited)
      myColor.a = 255;
    else
      myColor.a = 50;
    strokeWeight(1);
    if(!end)
      fill(myColor.r, myColor.g, myColor.b, myColor.a);
    else
    {
      strokeWeight(5);
      fill(255, 0,0, myColor.a);
    }
    ellipse(x, y, 21, 21); 
    strokeWeight(1);
  }

  boolean isInside(int x, int y)
  {
    return (myBlob.inside(x, y));
  }
}


class Maze
{
  Node root;
  int complexity;
  boolean hasEnd;
  int mySize;
  int myDepth;

  Background bg;

  Node currentNode;
  Maze( int cmplx, int depth )
  {
    complexity = cmplx;
    myDepth = depth;
    bg = new Background();
    Node temp;
    hasEnd = false;
    // Construct our maze.
    root = new Node();
    root.setParent(null);
    ++mySize;
    addTree(root, cmplx, depth-1);
    if(!hasEnd)
    {
      createEnd(root);
    }
    root.setVisited();
    currentNode = root;
  }

  void createEnd( Node rooter )
  {
    if((rooter.getChildren()).size() == 0)
    {
      rooter.setEnd();
    }
    else
    {
      createEnd( (Node)(rooter.getChildren()).get( (int)random(0,(rooter.getChildren()).size())));
    }
  }

  void addTree(Node rooter, int cmplx, int depth)
  {
    ArrayList children = new ArrayList();
    int childs = (int)random(depth, cmplx+1);
    for(int i=0; i<childs; ++i)
    {
      children.add(new Node());
      ++mySize;
      ((Node)children.get(i)).setParent(rooter);
      if(depth >= 0)
      {
        addTree((Node)children.get(i), cmplx, depth-1);
      }
    }
    rooter.setChildren(children);
  }

  void visitNode(Node node)
  {
    node.setVisited();
    currentNode = node; 
  }

  void render()
  {
    bg.render();

    if(currentNode.isEnd())
    {
        return;
    }

    if(currentNode != root)
    {
      currentNode.getParent().render();
    }
    ArrayList temp = currentNode.getChildren();
    for(int i = 0; i< temp.size(); ++i)
    {
      ((Node)temp.get(i)).render(); 
    }
    drawTree(root, width/2, 10, 0, width); 
  }

  void update()
  {
    bg.update();

    if(currentNode.isEnd())
    {
      bg.changeBG(new Color(0, 0, 0, 255));
      return; 
    }

    if(currentNode != root)
    {
      currentNode.getParent().update();
    }
    ArrayList temp = currentNode.getChildren();
    for(int i = 0; i< temp.size(); ++i)
    {
      ((Node)temp.get(i)).update(); 
    }
  }

  void mouseClick(int x, int y)
  {
    ArrayList temp = currentNode.getChildren();
    for(int i = temp.size()-1; i>=0; --i)
    {
      if(((Node)temp.get(i)).isInside(x, y))
      {
        ((Node)(currentNode.getChildren().get(i))).setVisited();
        currentNode =  (Node)(currentNode.getChildren().get(i));
        bg.changeBG(((Blob)currentNode.getBlob()).getColor());


        /*  
         for( int k = 0; k < temp.size(); ++k)
         {
         ((Blob)Blobs.get(k)).animate(2);
         }
         */
        return;
      }
    }
    if(currentNode != root)
    {
      if(currentNode.getParent().isInside(x, y))
      {
        currentNode.getParent().setVisited();
        currentNode =  currentNode.getParent();
        bg.changeBG(((Blob)currentNode.getBlob()).getColor());
        return;
      }
    }
  }

  void drawTree(Node rooter, int x, int y, int b, int e)
  { 
    ArrayList children = rooter.getChildren();
    if(children.size() > 0)
    {
      int step = (e-b)/(children.size()+1);
      int step2 = (e-b)/(children.size());
      for(int i = 0; i< children.size(); ++i)
      {
        strokeWeight(3);
        stroke(0, 0, 0, 50);//, (life/birth)*a);
        line(x, y, b + step*(i+1), y + ((height-30)/(myDepth+1)));
        if( ((Node)children.get(i)).hasVisited())
        {
          drawTree((Node)children.get(i), b + step*(i+1), y + ((height-30)/(myDepth+1)), b + step2*i, e - step2*(children.size()-1-i)); 
        }
      }     
    }
    if(rooter == currentNode )
      rooter.renderAtCurrent(x,y);
    else
      rooter.renderAt(x, y);
  }
  
  boolean isDone()
  {
     return currentNode.isEnd(); 
  }
}