// a point
class Point  {
  float x=0, y=0, z=0;
  int pcolor=255;
  int[] rgb = new int[3];
  boolean isRGB;
  
  Line on_line_1, on_line_2;
  Line on_lineZ_1, on_lineZ_2;
  Point[] children;
  
  // *** constructors ***
  Point()  {}
  Point(float xc)  {
    x = xc;
  }
  Point(float xc, float yc)  {
    x = xc;
    y = yc;
  }
  Point( float xc, float yc, float zc )  {
    x = xc;
    y = yc;
    z = zc;
  }
  // *** accessors ***
  public void X(float xc)  {  
    x = xc;
    NotifyChildren();
  }
  public void Y(float yc)  {  
    y = yc;
    NotifyChildren();
  }
  public void Z(float zc)  {  
    z = zc;
    NotifyChildren();
  }
  public void setColor(int c)  {
    isRGB = false;
    pcolor = c;
  }
  public void setColor(int r, int g, int b)  {
    isRGB = true;
    rgb[0] = r;
    rgb[1] = g;
    rgb[2] = b;
  }
  // *** methods ***
  public void drawPoint()  {
    if (isRGB)  {
      fill(rgb[0], rgb[1], rgb[2]);
    } else  {  fill(pcolor);  }
    noStroke();
    rect(x, y, 4, 4);
    rect(x, z, 4, 4);
  }
  
  public void onLines(Line l1, Line l2)  {
    on_line_1 = l1;
    on_line_2 = l2;
  }
  public void onLinesZ(Line l1, Line l2)  {
    on_lineZ_1 = l1;
    on_lineZ_2 = l2;
  }
  
  // event handlers
  void NotifyChildren()  {
    if (children.length == 0)  {return;}
    for (int i=0; i<children.length; i++)  {
      children[i].updatePosition();
    }
  }
  void updatePosition()  {
    X(on_line_1.getIntersect(on_line_2));
    Y(on_line_1.getY(x));
    Z(on_line_1.getZ(x));
  }
  void reposition(float mX, float mY)  {
    on_line_1.getSlopeY(); // update the slope
    float yint = mY - (-on_line_1.slope_y * mX); // get y intercept for same line with negative slope through current mouse position
    Point mP = new Point(mX, mY); // new temp point based on mouse position
    Line mL = new Line(mP, new Point(0,yint)); // new temp line through perspective point and mouse point
    Point line1_p = new Point(on_line_1.getIntersect(mL), on_line_1.getY(x)); // new temp point on temp line, used to measure distance to old line
    
    on_line_2.getSlopeY();
    yint = mY - (-on_line_2.slope_y*mX);
    Line mL2 = new Line(mP, new Point(0,yint));
    Point line2_p = new Point (on_line_2.getIntersect(mL2), on_line_2.getY(x));
    
    if (mP.getDist(line1_p) < mP.getDist(line2_p))  {
      X(line1_p.x);
      Y(line1_p.y);
      repoLine(on_line_2, line1_p);
    } else  {
      X(line2_p.x);
      Y(line2_p.y);
      repoLine(on_line_1, line2_p);
    }
  }
  
  void repositionBEl()  {
    Line newL1 = new Line(on_line_1.start, this);
    Line nL = (on_line_1.end.on_line_1 == on_line_1) ? on_line_1.end.on_line_2 : on_line_1.end.on_line_1;
    on_line_1.end.x = newL1.getIntersect(nL);
    on_line_1.end.y = nL.getY(on_line_1.end.x);
    
    Line newL2 = new Line(on_line_2.start, this);
    nL = (on_line_2.end.on_line_1 == on_line_2) ? on_line_2.end.on_line_2 : on_line_2.end.on_line_1;
    on_line_2.end.x = newL2.getIntersect(nL);
    on_line_2.end.y = nL.getY(on_line_2.end.x);
  }
  void repositionTEl(float mX, float mY)  {
    on_lineZ_1.getSlopeZ();
    float zint = mY - (-on_lineZ_1.slope_z * mX);
    Point mP = new Point(mX,0, mY);
    Line mL = new Line(mP, new Point(0,0,zint), ELEVATION);
    Point line1_p = new Point(on_lineZ_1.getIntersectZ(mL), 0, on_lineZ_1.getZ(x));

    on_lineZ_2.getSlopeZ();
    zint = mY - (-on_lineZ_2.slope_z*mX);
    Line mL2 = new Line(mP, new Point(0,0,zint), ELEVATION);
    Point line2_p = new Point (on_lineZ_2.getIntersectZ(mL2), 0, on_lineZ_2.getZ(x));
    
    if (mP.getDistZ(line1_p) < mP.getDistZ(line2_p))  {
      X(line1_p.x);
      Z(line1_p.z);
      repoLineZ(on_lineZ_2, line1_p);
    } else  {
      X(line2_p.x);
      Z(line2_p.z);
      repoLineZ(on_lineZ_1, line2_p);
    }
    
  }
  
  void repoLine(Line l, Point newP)  {
    // figure out which line the point lands on that you're not dealing with
    Line nL = (l == l.end.on_line_1) ? l.end.on_line_2 : l.end.on_line_1;
    // make a temporary new regulating line
    Line newL = new Line(l.start, newP);
    // reposition existing line to where new line and the not-line intersect
    l.end.X(newL.getIntersect(nL));
    l.end.Y(nL.getY(l.end.x));
  }
  void repoLineZ(Line l, Point newP)  {
    // figure out which line the point lands on that you're not dealing with
    Line nL = (l == l.end.on_lineZ_1) ? l.end.on_lineZ_2 : l.end.on_lineZ_1;
    // make a temporary new regulating line
    Line newL = new Line(l.start, newP, ELEVATION);
    // reposition existing line to where new line and the not-line intersect
    l.end.X(newL.getIntersectZ(nL));
    l.end.Z(nL.getZ(l.end.x));
  }
  
  float getDist(Point p)  {
    return dist( x, y, p.x, p.y);
  }
  float getDistZ(Point p)  {
    return dist(x, z, p.x, p.z);
  }
  
  void initChildren(Point p1)  {
    children = new Point[1];
    children[0] = p1;
  }
  void initChildren(Point p1, Point p2)  {
    children = new Point[2];
    children[0] = p1;
    children[1] = p2;
  }
}

// a base line point -- a point that lives on the baselines
class BLinePoint extends Point {

  BLinePoint( int xc, Line l_1, Line l_2 )  {
    x = xc;
    on_line_1 = l_1;
    on_line_2 = l_2;
    z = on_line_1.getY(x);
    y = on_line_2.getY(x);
  }    
  
  public void X(float xc)  {
    x = xc;
    z = on_line_1.getY(x);
    y = on_line_2.getY(x);
    NotifyChildren();
  }
  
  public void drawPoint()  {
    if (isRGB)  {
      fill(rgb[0], rgb[1], rgb[2]);
    } else  {  fill(pcolor);  }
    noStroke();
    rect(x, z, 4,4);
    rect(x, y, 4,4);
  }
  
  void updatePosition()  {
    Z(on_line_1.getY(x));
    Y(on_line_2.getY(x));
  }
    
}

// a line, construct with two endpoints
class Line {
  Point start, end;
  int lcolor=255;
  int[] rgb;
  float slope_y, slope_z;
  float y_int, z_int;
  boolean isRGB;
  int plane = PLAN;
  
  // *** constructors ***
  Line(Point s, Point e)  {
    start = s;
    end = e;
  }
  Line(Point s, Point e, int pl)  {
    start = s;
    end = e;
    plane = pl;
  }
  
  // *** accessors ***
  public void setStart(Point s)  {
    start = s;
  }
  public void setEnd(Point e)  {
    end = e;
  }
  public void setColor(int c)  {
    isRGB = false;
    lcolor = c;
  }
  public void setColor(int a, int b, int c)  {
    isRGB = true;
    rgb = new int[3];
    rgb[0] = a;
    rgb[1] = b;
    rgb[2] = c;
  }
  
  // *** methods ***  
  // draw this line
  public void drawLine()  {
    if (isRGB) { stroke(rgb[0],rgb[1],rgb[2]); }
    else  { stroke(lcolor); }
    noFill();
    if (plane == PLAN)  {
      line(start.x, start.y, end.x, end.y);
    }
    else   {
      line(start.x, start.z, end.x, end.z);
    }
  }
  public float getX(float y)  {
    float s = (end.y-start.y)/(end.x-start.x);
    float y_i = start.y - s*start.x;
    return (y - y_i)/s;
  }
  // get y coordinate given x coordinate
  public float getY(float x)  {
    getSlopeY();
    getYInt();
    return (slope_y*x) + y_int;
  }
  public float getZ(float x)  {
    getSlopeZ();
    getZInt();
    return (slope_z*x) + z_int;
  }
  // find x coordinate of intersection with another line
  public float getIntersect(Line l)  {
    getSlopeY();
    l.getSlopeY();
    getYInt();
    l.getYInt();
    return (l.y_int - y_int)/(slope_y - l.slope_y);
  }
  public float getIntersectZ(Line l)  {
    getSlopeZ();
    l.getSlopeZ();
    getZInt();
    l.getZInt();
    return (l.z_int - z_int)/(slope_z - l.slope_z);
  }
  
  void getSlopeY()  {
    slope_y = (end.y-start.y)/(end.x-start.x);
  }
  void getYInt()  {
    y_int = start.y - (slope_y*start.x);
  }
  void getSlopeZ()  {
    slope_z = (end.z-start.z)/(end.x-start.x);
  }
  void getZInt()  {
    z_int = start.z - (slope_z*start.x);
  }

}

// regulating lines
class RLine extends Line  {
  boolean isRGB = false;
  int lcolor = 125;
  
  RLine(Point s, Point e)  {
    super(s, e);
    setColor(125);
  }
  RLine(Point s, Point e, int pl)  {
    super(s, e, pl);
    setColor(125);
  }
    
}

// a horizontal line
class HLine extends Line  {
  float height;
  HLine(float ypos)  {
    super(new Point(0.0, ypos), new Point(width, ypos));
    height = ypos;
  }
}

// baseline == has moveable endpoints
class BLine extends Line  {
  
  BLine(Point s, Point e)  {
    super(s, e);
    s.setColor(0,155,0);
    e.setColor(0,155,0);
  }
  
  public void drawLine()  {
    if (isRGB) { stroke(rgb[0],rgb[1],rgb[2]); }
    else  { stroke(lcolor); }
    noFill();
    line(start.x, start.y, end.x, end.y);
    start.drawPoint();
    end.drawPoint();
  }
}