// fills fully transparent pixels in the image with
// the color of the (roughly) closest non-transparent neighbor pixel

sclass ImageInfiller {
  settable BufferedImage inputImage;
  
  // how far to infill (pixels)
  settable int maxDepth = 2;
  
  // whether to make the infilled pixels (semi-) transparent
  settable int infillOpacity = 255;
  
  settable bool verbose;
  
  int w, h;
  int[] pixels;
  IntBuffer queue; // pixel indices for current round
  IntBuffer nextQueue; // pixel indices for next round
  BufferedImage outputImage;
  gettable int rounds;
  gettable int filledPixels;
  
  *() {}
  *(BufferedImage *inputImage) {}
  *(BufferedImage *inputImage, int *maxDepth) {}
  
  run {
    prepare();
    while (!done())
      oneRound();
  }
  
  bool prepared() { ret pixels != null; }
  
  bool done() {
    ret nextQueue != null && nextQueue.isEmpty()
      || rounds >= maxDepth;
  }
  
  BufferedImage get() {
    run();
    ret pixelsToBufferedImage(pixels, w);
  }
  
  void prepare {
    if (pixels != null) ret;
    pixels = pixelsFromBufferedImage(inputImage);
    w = inputImage.getWidth();
    h = inputImage.getHeight();
  }
  
  void oneRound {
    ++rounds;
    queue = nextQueue;
    nextQueue = new IntBuffer;
    new BitSet queued;
    assertBetween("infillOpacity", 1, 255, infillOpacity);
    
    new IntBuffer toFill; // pixel index, color, pixel index, color, ...
    for (pos : queue == null ? countIterator(w*h) : queue) {
      int rgba = pixels[pos];
      if (!isFullyTransparent(rgba)) continue;
      
      int x = pos % w, y = pos/w;
      new MultiSet<Int> surroundingColors;
      for (int y2 = max(0, y-1); y2 < min(h, y+2); y2++)
        for (int x2 = max(0, x-1); x2 < min(w, x+2); x2++) {
          rgba = pixels[y2*w+x2];
          if (!isFullyTransparent(rgba))
            surroundingColors.add(withOpacity(infillOpacity, rgba));
        }
        
      if (!surroundingColors.isEmpty()) {
        // Surrounding color found, fill pixel
        toFill.add(y*w+x);
        toFill.add(surroundingColors.mostPopular());
        filledPixels++;
        // Schedule surrounding transparent pixels
        for (int y2 = max(0, y-1); y2 < min(h, y+2); y2++)
          for (int x2 = max(0, x-1); x2 < min(w, x+2); x2++) {
            int pos2 = y2*w+x2;
            if (!queued.get(pos2) && isFullyTransparent(pixels[pos2])) {
              queued.set(pos2);
              nextQueue.add(pos2);
            }
          }
      }
    }

    queue = null;
    int n = l(toFill);
    for (int i = 0; i < n; i += 2)
      pixels[toFill.get(i)] = toFill.get(i+1);
      
    if (verbose)
      print("Round " + rounds + " pixels filled: " + n2(filledPixels) + ", nextQueue: " + l(nextQueue));
  }
 
  selfType unlimited() {
    maxDepth(Int.MAX_VALUE);
    this;
  }
  
  void eraseOriginalPixels {
    run();
    if (infillOpacity >= 255) fail("Need semi-transparency to erase original pixels");
    int[] pixels = this.pixels;
    for i over pixels:
      if (!isTransparent(pixels[i]))
        pixels[i] = 0;
  }
  
  // works only after at least one round was run
  int nRemainingTransparentPixels() {
    ret nextQueue.size();
  }
}