sclass BaseBase {
  S globalID = aGlobalID();
  S text;
  S textForRender() { ret text; }
}

sbool traits_multiLine = true;

sclass Base extends BaseBase {
  new L<S> traits;
  bool hasTrait(S t) { ret containsIC(traits(), t); }
  L<S> traits() { if (nempty(text) && neq(first(traits), text)) traits.add(0, text); ret traits; }
  void addTraits(L<S> l) { setAddAll(traits(), l); }
  void addTrait(S t) { if (nempty(t)) setAdd(traits(), t); }
  
  S textForRender() {
    L<S> traits = traits();
    if (traits_multiLine) ret lines_rtrim(traits);
    if (l(traits) <= 1) ret first(traits);
    ret first(traits) + " [" + join(", ", dropFirst(traits)) + "]";
  }
  
  void setText(S text) {
    this.text = text;
    traits = ll(text);
  }
}

sclass CirclesAndLines {
  new L<Circle> circles;
  new L<Line> lines;
  Class<? extends Arrow> arrowClass = Arrow;
  Class<? extends Circle> circleClass = Circle;
  S title;
  S globalID = aGlobalID();
  long created = nowUnlessLoading();
  transient Lock lock = fairLock();
  transient S defaultImageID = #1007372;
  transient double imgZoom = 1; // zoom for the circle images
  transient Pt translate;
  Circle hoverCircle; // which one we are hovering over
  transient O onUserMadeArrow, onUserMadeCircle, onLayoutChange;
  transient O onFullLayoutChange, onDeleteCircle, onDeleteLine;
  transient O onRenameCircle, onRenameLine, onStructureChange;
  transient BufferedImage imageForUserMadeNodes;
  static int maxDistanceToLine = 20; // for clicking
  transient S backgroundImageID = defaultBackgroundImageID;
  static S defaultBackgroundImageID = #1007195;
  static Color defaultLineColor = Color.white;
  static bool debugRender;
  static O staticPopupExtender;
  transient double scale = 1; // zoom whole image
  transient bool recordHistory = true;
  L history;

  // auto-visualize
  Circle circle_autoVis(S text, S visualizationText, double x, double y) {
    ret addAndReturn(circles,
      nu(circleClass, +x, +y, +text,
        quickvis := visualizationText,
        img := processImage(quickVisualizeOr(visualizationText, defaultImageID))));
  }
  
  S makeVisualizationText(S text) {
    ret possibleGlobalID(text) ? "" : text;
  }

  Circle circle_autoVis(S text, double x, double y) {
    ret circle_autoVis(text, makeVisualizationText(text), x, y);
  }
  
  Circle circle(BufferedImage img, double x, double y, S text) {
    ret addAndReturn(circles, nu(circleClass, +x, +y, +text, img := processImage(img));
  }
  
  Circle circle(S text, BufferedImage img, double x, double y) {
    ret circle(img, x, y, text);
  }
  
  Circle circle(S text, double x, double y) {
    ret addAndReturn(circles, nu(circleClass, +x, +y, +text, img := processImage(imageForUserMadeNodes());
  }
  
  Circle addCircle(S imageID, double x, double y) {
    ret addCircle(imageID, x, y, "");
  }
  
  Circle addCircle(S imageID, double x, double y, S text) {
    ret addAndReturn(circles, nu(circleClass, +x, +y, +text, img := processImage(loadImage2(imageID))));
  }
  
  Arrow findArrow(Circle a, Circle b) {
    for (Line l : getWhere(lines, +a, +b))
      if (l instanceof Arrow)
        ret (Arrow) l;
    null;
  }
  
  Line addLine(Circle a, Circle b) {
    Line line = findWhere(lines, +a, +b);
    if (line == null)
      lines.add(line = nu(Line, +a, +b));
    ret line;
  }
  
  Arrow arrow(Circle a, S text, Circle b) {
    ret addArrow(a, b, text);
  }
  
  Arrow addArrow(Circle a, Circle b) {
    ret addArrow(a, b, "");
  }
  
  Arrow addArrow(Circle a, Circle b, S text) {
    ret addAndReturn(lines, nu(arrowClass, +a, +b, +text));
  }
  
  BufferedImage makeImage(int w, int h) {
    BufferedImage bg = renderTiledBackground(backgroundImageID, w, h, ptX(translate), ptY(translate));
    if (!lock.tryLock()) null;
    try {
      if (scale != 1)
        createGraphics_modulate(bg, voidfunc(Graphics2D g) {
          g.scale(scale, scale);
        });
      
      // Lines
      
      if (debugRender)
        print("Have " + n(lines, "line"));
      
      // flipMap is false for bidirectional connections
      
      HashMap<Pair<Circle>, Line> hasLine = new HashMap;
      new HashMap<Line, Bool> flipMap;
      for (Line l : lines) {
        hasLine.put(pair(l.a, l.b), l);
        Line x = hasLine.get(pair(l.b, l.a));
        if (x != null) {
          if (debugRender)
            print("flipMap " + l.a.text + " / " + l.b.text);
          flipMap.put(x, false);
          flipMap.put(l, false);
        }
      }

      for (Line l : lines) {
        DoublePt a = translateDoublePt(translate, l.a.doublePt(w, h, this));
        DoublePt b = translateDoublePt(translate, l.b.doublePt(w, h, this));
        if (debugRender)
          print("Line " + a + " " + b);
        if (l instanceof Arrow)
          drawThoughtArrow(bg, l.a.img(this), iround(a.x), iround(a.y), l.b.img(this), iround(b.x), iround(b.y), l.color);
        else
          drawThoughtLine(bg, l.a.img(this), iround(a.x), iround(a.y), l.b.img(this), iround(b.x), iround(b.y), l.color);
        S text = l.textForRender();
        if (nempty(text)) {
          Bool flip = flipMap.get(l);
          drawOutlineTextAlongLine_flip.set(flip);
          
          // mark bidirectional arrow labels with direction for clarity
          if (flip != null) text += " " + unicode_blackRightArrow();
          
          drawThoughtLineText_multiLine(bg, l.a.img(this), iround(a.x), iround(a.y), l.b.img(this), iround(b.x), iround(b.y), text, Color.white /*l.color*/);
        }
      }
      
      // Circles
      
      for (Circle c : circles) {
        DoublePt p = translateDoublePt(translate, c.doublePt(w, h, this));
        drawThoughtCircle(bg, c.img(this), p.x, p.y);
      }
      
      for (Circle c : circles) {
        DoublePt p = translateDoublePt(translate, c.doublePt(w, h, this));
        S text = c.textForRender();
        if (nempty(text))
          drawThoughtCircleText(bg, c.img(this), p, text);
          
        if (c == hoverCircle)
          drawThoughtCirclePlus(bg, c.img(this), p.x, p.y);
      }
    } finally {
      lock.unlock();
      createGraphics_modulate(bg, null);
    }
    ret bg;
  }
  
  Canvas showAsFrame(int w, int h) {
    Canvas canvas = showAsFrame();
    frameInnerSize(canvas, w, h);
    centerFrame(getFrame(canvas));
    ret canvas;
  }
  
  Canvas showAsFrame() {
    ret (Canvas) swing(func {
      Canvas canvas = makeCanvas();
      showCenterFrame(canvas);
      ret canvas;
    });
  }
  
  Canvas makeCanvas() {
    fO makeImg = func(int w, int h) { makeImage(w, h) };
    final Canvas canvas = jcanvas(makeImg);
    disableImageSurfaceSelector(canvas);
    new CircleDragger(this, canvas, r { updateCanvas(canvas, makeImg) });
    
    componentPopupMenu(canvas, voidfunc(JPopupMenu menu) {
      // POPUP MENU START
      Pt p = pointFromEvent(canvas, componentPopupMenu_mouseEvent.get());
      JMenu imageMenu = jmenu("Image");
      moveAllMenuItems(menu, imageMenu);

      addMenuItem(menu, "New Circle...", r { newCircle(canvas) });
      
      final Line l = findLine(canvas, p);
      if (l != null) {
        addMenuItem(menu, "Rename Relation...", r {
          renameLine(canvas, l)
        });
        
        addMenuItem(menu, "Delete Relation", r {
          deleteLine(l);
          canvas.update();
        });
      }
      
      final Circle c = findCircle(canvas, p);
      if (c != null) {
        addMenuItem(menu, "Rename Circle...", r { renameCircle(canvas, c) });
        addMenuItem(menu, "Delete Circle", r {
          deleteCircle(c);
          canvas.update();
        });
        
        if (c.img != null || c.quickvis != null)
          addMenuItem(menu, "Delete Image", r {
            c.img = null;
            c.quickvis = null;
            canvas.update();
          });
          
        if (neqic(c.text, c.quickvis))
          addMenuItem(menu, "Visualize", r {
            thread "Visualizing" {
              quickVisualize(c.text);
              print("Quickvis done");
              swing {
                c.img = null;
                c.quickvis = c.text;
                canvas.update();
                pcallF(onRenameCircle, c); schange();
              }
            }
          });
      }
      
      addMenuItem(menu, "Copy structure to clipboard", r {
        copyTextToClipboard(cal_simplifiedStructure(CirclesAndLines.this))
      });

      addMenuItem(menu, "Paste structure", r {
        S text = getTextFromClipboard();
        if (nempty(text)) {
          copyCAL(cal_unstructure(text), CirclesAndLines.this);
          canvas.update();
          schange();
        }
      });
      
      pcallF(staticPopupExtender, CirclesAndLines.this, canvas, menu);
      
      addMenuItem(menu, imageMenu);

      // POPUP MENU END
    });
    
    ret canvas;
  }
  
  void newCircle(final Canvas canvas) {
    final JTextField text = jtextfield();
    showFormTitled("New Circle", "Text", text, r-thread { loading {
      S theText = getTextTrim(text);
      makeCircle(theText);
      canvas.update();
    }});
  }
  
  Canvas show() { ret showAsFrame(); }
  Canvas show(int w, int h) { ret showAsFrame(w, h); }
  
  Circle findCircle(S text) {
    for (Circle c : circles) if (eq(c.text, text)) ret c;
    for (Circle c : circles) if (eqic(c.text, text)) ret c;
    null;
  }
  
  void renameCircle(final Canvas canvas, final Circle c) {
    final JTextField tf = jtextfield(c.text);
    showFormTitled("Rename circle",
      "Old name", jlabel(c.text),
      "New name", tf,
      r {
        c.setText(getTextTrim(tf));
        canvas.update();
        pcallF(onRenameCircle, c); schange();
      });
  }
  
  void renameLine(final Canvas canvas, final Line l) {
    final JTextField tf = jtextfield(l.text);
    showFormTitled("Rename relation",
      "Old name", jlabel(l.text),
      "New name", tf,
      r {
        l.setText(getTextTrim(tf));
        canvas.update();
        pcallF(onRenameLine, l); schange();
      });
  }
  
  void clear {
    clearAll(circles, lines);
  }
  
  // only finds actually containing circles
  Circle findCircle(ImageSurface canvas, Pt p) {
    p = untranslatePt(translate, p);
    new Lowest<Circle> best;
    for (Circle c : circles)
      if (c.contains(this, canvas, p))
        best.put(c, pointDistance(p, c.pt2(this, canvas)));
    ret best!;
  }
  
  Circle findNearestCircle(ImageSurface canvas, Pt p) {
    new Lowest<Circle> best;
    for (Circle c : circles)
      if (c.contains(this, canvas, p))
        best.put(c, pointDistance(p, c.pt2(this, canvas)));
    ret best.get();
  }
  
  BufferedImage processImage(BufferedImage img) {
    ret scaleImage(img, imgZoom);
  }
  
  void deleteCircle(Circle c) {
    for (Line l : cloneList(lines))
      if (l.a == c || l.b == c) deleteLine(l);
    circles.remove(c);
    pcallF(onDeleteCircle, c); schange();
  }
  
  void deleteLine(Line l) {
    lines.remove(l);
    pcallF(onDeleteLine, l); schange();
  }
  
  void openPlusDialog(final Circle c, final ImageSurface canvas) {
    if (c == null) ret;
    
    final JTextField tfFrom = jtextfield(c.text);
    final JTextField tfRel = jtextfield(web_defaultRelationName());
    final JComboBox tfTo = autoComboBox(collect(circles, 'text));
    
    showFormTitled("Add connection",
      "From node", tfFrom,
      "Connection name", tfRel,
      "To node", tfTo,
      func {
        S sA = getTextTrim(tfFrom);
        Circle a = eq(sA, c.text) ? c : findOrMakeCircle(sA);
        if (a == null) { messageBox("Not found: " + getTextTrim(tfFrom)); false; }
        Circle b = findOrMakeCircle(getTextTrim(tfTo));
        if (b == null) { messageBox("Not found: " + getTextTrim(tfTo)); false; }
        if (a == b) { infoBox("Can't connect circle to itself for now"); false; }
        Arrow arrow = arrow(a, getTextTrim(tfRel), b);
        ((Canvas) canvas).update();
        pcallF(onUserMadeArrow, arrow); schange();
        null;
      });
    awtLater(tfRel, 100, r { requestFocus(tfRel) });
  }
  
  void schange() {
    pcallF(onStructureChange);
    logQuoted("user-web-edits", now() + " " + cal_structure(this));
    markWebsPosted();
  }
  
  Circle findOrMakeCircle(S text) {
    Circle c = findCircle(text);
    if (c != null) ret c;
    ret makeCircle(text);
  }

  Circle makeCircle(S text) {
    Circle c = circle(imageForUserMadeNodes(), random(0.1, 0.9), random(0.1, 0.9), text);
    pcallF(onUserMadeCircle, c); schange();
    historyLog(lisp("Made circle", text));
    ret c;
  }

  BufferedImage imageForUserMadeNodes() {  
    if (imageForUserMadeNodes == null)
      imageForUserMadeNodes = whiteImage(20, 20);
    ret imageForUserMadeNodes;
  }
  
  Line findLine(Canvas is, Pt p) {
    p = untranslatePt(translate, p);
    new Lowest<Line> best;
    for (Line line : lines) {
      double d = distancePointToLineSegment(line.a.pt(this, is), line.b.pt(this, is), p);
      if (d <= maxDistanceToLine)
        best.put(line, d);
    }
    ret best!;
  }
  
  Pt pointFromEvent(ImageSurface canvas, MouseEvent e) {
    ret scalePt(canvas.pointFromEvent(e), 1/scale);
  }
  
  void historyLog(O o) {
    if (!recordHistory) ret;
    if (history == null) history = new L;
    history.add(o);
  }
} // end of class CirclesAndLines

sclass Circle extends Base {
  transient BufferedImage img;
  double x, y;
  //static BufferedImage defaultImage;
  S quickvis;
  
  BufferedImage img(CirclesAndLines cal) {
    if (img != null) ret img;
    if (nempty(quickvis)) img = quickVisualize(quickvis);
    //if (defaultImage == null) defaultImage = loadImage2(#1007372);
    ret cal.imageForUserMadeNodes();
  }
  
  Pt pt2(CirclesAndLines cal, ImageSurface is) {
    ret pt2(is.getWidth(), is.getHeight(), cal);
  }
  
  Pt pt(CirclesAndLines cal, ImageSurface is) {
    ret pt(is.getWidth(), is.getHeight(), cal);
  }
  
  Pt pt(int w, int h, CirclesAndLines cal) {
    ret new Pt(iround(x*w/cal.scale), iround(y*h/cal.scale));
  }
  
  Pt pt2(int w, int h, CirclesAndLines cal) {
    ret new Pt(iround(x*w), iround(y*h));
  }
  
  DoublePt doublePt(int w, int h, CirclesAndLines cal) {
    ret new DoublePt(x*w/cal.scale, y*h/cal.scale);
  }
  
  bool contains(CirclesAndLines cal, ImageSurface is, Pt p) {
    ret pointDistance(p, pt2(cal, is)) <= iround(thoughtCircleSize(img(cal))*cal.scale)/2+1;
  }
}

sclass Line extends Base {
  Circle a, b;
  transient Color color = CirclesAndLines.defaultLineColor;
  
  Line setColor(Color color) {
    this.color = color;
    this;
  }
}

Line > Arrow {}

sclass CircleDragger extends MouseAdapter {
  CirclesAndLines cal;
  ImageSurface is;
  O update;
  int dx, dy;
  Circle circle;
  Pt startPoint;
  
  *(CirclesAndLines *cal, ImageSurface *is, O *update) {
    if (containsInstance(is.tools, CircleDragger)) ret;
    is.tools.add(this);
    is.addMouseListener(this);
    is.addMouseMotionListener(this);
  }

  public void mouseMoved(MouseEvent e) {
    Pt p = is.pointFromEvent(e);
    Circle c = cal.findCircle(is, p);
    if (c != cal.hoverCircle) {
      cal.hoverCircle = c;
      callF(update);
    }
  }
  
  public void mousePressed(MouseEvent e) {
    if (e.getButton() == MouseEvent.BUTTON1) {
      Pt p = is.pointFromEvent(e);
      startPoint = p;
      circle = cal.findCircle(is, p);
      if (circle != null) {
        dx = p.x-iround(circle.x*is.getWidth());
        dy = p.y-iround(circle.y*is.getHeight());
        //printVars("mousePressed", +dx, +dy, +p, cx := circle.x, cy := circle.y, w := is.getWidth(), h := is.getHeight());
      } else { 
        Pt t = unnull(cal.translate);
        dx = p.x-t.x;
        dy = p.y-t.y;
      }
    }
  }

  public void mouseDragged(MouseEvent e) {
    if (startPoint == null) ret;
    Pt p = is.pointFromEvent(e);
    if (circle != null) {
      circle.x = (p.x-dx)/(double) is.getWidth();
      circle.y = (p.y-dy)/(double) is.getHeight();
      //printVars("mouseDragged", +dx, +dy, +p, cx := circle.x, cy := circle.y, w := is.getWidth(), h := is.getHeight());
      pcallF(cal.onLayoutChange, circle);
      callF(update);
    } else {
      cal.translate = new Pt(p.x-dx, p.y-dy);
      callF(update);
    }
  }

  public void mouseReleased(MouseEvent e) {
    mouseDragged(e);
    if (eq(is.pointFromEvent(e), startPoint))
      cal.openPlusDialog(circle, is);
    circle = null;
    startPoint = null;
  }
}