// For users of this class: Don't fill the maps directly, call
// mapAnchor + mapCurve.

srecord noeq G22MeshMapping(G22Mesh mesh1, G22Mesh mesh2) {
  delegate Anchor, Curve to G22Mesh.
  
  // A mapping of a curve to another curve may be "flipped"
  // (start becomes end and end becomes start)
  srecord MappedCurve(Curve curve, bool flipped) {
    Curve get() { ret curve; }
    
    Anchor start() { ret curve.anchor(flipped); }
    Anchor end()   { ret curve.anchor(!flipped); }
  }

  // For both maps: keys are from mesh1, values are from mesh2
  BijectiveMap<Anchor> anchorMap = new BijectiveMap(true);
  
  // forward (mesh1 -> mesh2) and backward (mesh2 -> mesh1)
  new LinkedHashMap<Curve, MappedCurve> curveMap;
  new LinkedHashMap<Curve, MappedCurve> curveBackwardMap;
  
  // General validity check that should cover all bases
  
  void validityCheck() {
    if (mesh1 == mesh2)
      fail("Mesh1 and mesh2 must not be the same object");
      
    // For anchors, we only need to check that they come from the
    // right meshes. Bijectiveness is ensured by anchorMap itself.
    
    for (a1, a2 : anchorMap) {
      assertAnchorInMesh(a1, +mesh1);
      assertAnchorInMesh(a2, +mesh2);
    }
    
    for (c1, c2 : curveMap) {
      assertTrue(c1 + " is in mesh1", mesh1.containsCurve(c1));
      assertTrue(c2 + " is in mesh2", mesh2.containsCurve(c2!));
      
      // Check compatibility with anchor mappings
      
      assertEquals("Start point", c2.start(), getAnchorMapping(c1.start));
      assertEquals("End point", c2.end(), getAnchorMapping(c1.end));
    }
  }
  
  S validityError() {
    try {
      validityCheck();
      null;
    } catch e {
      ret "Validity error: " + e.getMessage();
    }
  }
  
  bool isValid() { ret validityError() == null; }
  
  // A mapping is complete iff all anchors and curves from both
  // meshes are covered.
  
  bool isComplete() {
    ret allEq(l(anchorMap), l(mesh1.anchors()), l(mesh2.anchors()))
      && allEq(l(curveMap), l(mesh1.curves()), l(mesh2.curves()));
  }
  
  void assertAnchorInMesh(Anchor a, S meshName, G22Mesh mesh) {
  assertTrue(a + " is in " + meshName, mesh.containsAnchor(a));
  }
  
  AutoCloseable tempMapAnchor(Anchor a1, Anchor a2) {
    assertAnchorInMesh(a1, +mesh1);
    assertAnchorInMesh(a2, +mesh2);
    ret tempMapPut(anchorMap, a1, a2);
  }
 
  void mapAnchor(Anchor a1, Anchor a2) {
    assertAnchorInMesh(a1, +mesh1);
    assertAnchorInMesh(a2, +mesh2);
    anchorMap.put(a1, a2);
  }
  
  // Note: doesn't remove the curve mappings
  void unmapAnchor(Anchor a1) {
    anchorMap.remove(a1);
  }
  
  AutoCloseable tempMapCurve(Curve c1, Curve c2, bool flipped) {
    new L<AutoCloseable> closers;
    
    var forwardMapping = new MappedCurve(c2, flipped);
    var backwardMapping = new MappedCurve(c1, flipped);
    closers.add(tempMapPut(curveMap, c1, forwardMapping));
    closers.add(tempMapPut(curveBackwardMap, c2, backwardMapping));
    
    // Automatically map the anchors
    closers.add(tempMapAnchor(c1.start, forwardMapping.start());
    closers.add(tempMapAnchor(c1.end, forwardMapping.end());
    ret combineAutoCloseables(closers);
  }
  
  void mapCurve(Curve c1, Curve c2, bool flipped) {
    var forwardMapping = new MappedCurve(c2, flipped);
    var backwardMapping = new MappedCurve(c1, flipped);
    curveMap.put(c1, forwardMapping);
    curveBackwardMap.put(c2, backwardMapping);
    
    // Automatically map the anchors
    mapAnchor(c1.start, forwardMapping.start());
    mapAnchor(c1.end, forwardMapping.end());
  }
  
  // The following functions take anchors and curves from either mesh
  
  Anchor getAnchorMapping aka get(Anchor a) {
    try object anchorMap.get(a);
    ret anchorMap.inverseGet(a);
  }
  
  MappedCurve getCurveMapping aka get(Curve c) {
    try object curveMap.get(c);
    ret curveBackwardMap.get(c);
  }
  
  bool isMapped(Anchor a) {
    ret get(a) != null;
  }
  
  bool isMapped(Curve c) {
    ret get(c) != null;
  }
  
  L<Int> anchorMappingIndices() {
    var idx = mapItemsToListIndex(mesh2.anchorList());
    ret map(mesh1.anchorList(), a -> idx.get(get(a)));
  }
  
  L<Int> curveMappingIndices() {
    var idx = mapItemsToListIndex(mesh2.curveList());
    ret map(mesh1.curveList(), a -> {
      var c = get(a);
      ret c == null ?: idx.get(c!);
    });
  }
  
  toString {
    ret "Mapped anchors: " + anchorMappingIndices()
      + ", mapped curves: " + curveMappingIndices();
  }
  
  void drawMappedPartOfMesh1(Graphics2D g) {
    for (anchor : keys(anchorMap))
      new G22VisualizeMeshes().drawAnchor(g, anchor.pt);
    for (curve : keys(curveMap))
      new G22VisualizeMeshes().drawCurve(g, curve);
  }
  
  void drawMappedPartOfMesh2(Graphics2D g) {
    for (anchor : values(anchorMap))
      new G22VisualizeMeshes().drawAnchor(g, anchor.pt);
    for (curve : values(curveMap)) {
      new G22VisualizeMeshes vm;
      if (curve.flipped)
        vm.curveColor(Color.green);
      vm.drawCurve(g, curve!);
    }
  }
}