!include #1000522 // image helper functions

sclass Best {
  S desc;
  double score;
  Renderer renderer;
  BWImage image;
  
  *() {}
  *(S *desc, double *score, BWImage *image) {}
  *(S *desc, double *score, Renderer *renderer, BWImage *image) {}
  
  int l() { ret main.l(desc); }
}

static O rendererMaker; // optional maker function (S -> Renderer)

sclass Reproducing {
  BWImage bw; // original
  ImageSurface imageSurfaceToUpdateWithBest;
  new LinkedBlockingQueue<S> newProducts;
  int maxQueueLength = 10;
  volatile Best shortest100, best;
  int pivotLength = -1; // no length punishment at start
  int pivotStep = 1;
  int fullGrabLength; // length of full grab for reference
  O startProduction; // optional runnable that starts production
  int descPrintLength = 100;

  void push(S product) {
    if (product == null) ret;
    while (newProducts.size() >= maxQueueLength && mayRun())
      sleep(100);
    newProducts.add(product);
  }
  
  double formula(S desc, double pixelScore) {
    int lengthPunishment = pivotLength < 0 ? 0
      : max(0, l(desc)-pivotLength);
    ret pixelScore-lengthPunishment;
  }
  
  void loadShortest100() {
    S shortest = shortest100();
    if (shortest != null)
      shortest100 = new Best(shortest, 100, null);
  }
  
  void reproduceOpenEnd() {
    loadShortest100();
    best = null;
    fullGrabLength = l(fullGrab(bw));
    long lastPrint = 0, lastN = 0;
    for (long ntry = 1; ; ntry++) {
      ping();
      long now = now();
      if (now >= lastPrint+1000) {
        long tps = (ntry-lastN)*1000/(now-lastPrint);
        lastPrint = now;
        lastN = ntry;
        String s = "Try " + ntry + " (" + tps + "/s)";
        if (best == null)
          print(s);
        else {
          print("Best: " + shorten(best.desc, descPrintLength));
          print(s + ", score: " + formatDouble(best.score, 2) + "%, l=" + l(best.desc) + ", pivotL=" + pivotLength + "/" + fullGrabLength + (shortest100 == null ? "" : ", shortest100=" + shortest100.l()));
        }
      }
      S desc;
      try {
        desc = grabFromQueue(newProducts);
      } catch e {
        print("Production failed: " + exceptionToStringShort(e));
        continue;
      }
      Renderer p;
      try {
        p = makeRenderer(desc);
      } catch {
        print("Can't unstructure: " + desc);
        continue;
      }
      
      BWImage rendering = render(p, bw);
      double pixelScore = 100*(1-diff(bw, rendering));
      double score = formula(desc, pixelScore);
      
      if (best == null || p != null && score > getScore(best)) {
        //System.out.println("New best! " + score);
        best = new Best(desc, score, p, rendering);
        if (pixelScore >= 100 && (shortest100 == null || shortest100.l() > l(desc))) {
          shortest100 = new Best(desc, pixelScore, rendering);
          saveTextFile(getProgramFile("shortest100.txt"), bw.getWidth() + " " + bw.getHeight() + " " + desc);
        }
        imageSurfaceToUpdateWithBest.setImage(best.image.getBufferedImage());
      }
      
      if (solved()) {
        print("Solved! l=" + best.l());
        print(shorten(best.desc, descPrintLength));
        break;
      }
    }
  }
  
  bool solved() {
    ret getScore(best) >= 100.0;
  }
  
  S bestDesc() {
    ret getDesc(best);
  }
  
  BufferedImage descToImage(S desc) {
    try {
      ret makeRenderer(desc).render(bw.getWidth(), bw.getHeight()).getBufferedImage();
    } catch {
      fail(desc);
    }
  }
  
  void produce() {
    callF(startProduction);
  }
  
  void findShortest100_openEnd() {
    produce();
    reproduceOpenEnd();
  
    while (solved()) {
      pivotLength = best.l() - pivotStep;
      print("Trying pivot length " + pivotLength);
  
      produce();
      reproduceOpenEnd();
    }
  }
}

static class FullGrab extends Renderer {
  int dw, dh;
  byte[] data;
  
  BWImage render(int w, int h) {
    if (w != dw || h != dh)
      fail("size: \*w*/ \*h*/ \*dw*/ \*dh*/");
    ret new BWImage(w, h, data);
  }
}

static class HRepeat extends Renderer {
  int width;
  S inner;
  
  BWImage render(int w, int h) {
    BWImage img = new BWImage(w, h);
    BWImage clip = ((Renderer) unstructure(inner)).render(width, h);
    for (int x = 0; x < w; x += width)
      copy(clip, 0, 0, img, x, 0, width, h);
    ret img;
  }
}
  
static S fullGrab(BWImage img) {
  DynamicObject d = new DynamicObject("FullGrab");
  int w = img.getWidth(), h = img.getHeight();
  d.put("dw", w);
  d.put("dh", h);
  byte[] data = new byte[w*h];
  for (int y = 0; y < h; y++)
    for (int x = 0; x < w; x++)
      data[y*w+x] = img.getByte(x, y);
  d.put("data", data);
  ret structure(d);
}

static S hrepeat(BWImage img, int width) {
  int h = img.getHeight();
  BWImage clip = img.clip(0, 0, width, h);
  ret structure(dynamicObject("HRepeat", "width", width, "inner", fullGrab(clip)));
}

static S varyFloat(S s) {
  L<S> tok = javaTok(s);
  int i = tok.indexOf("f");
  if (i < 0) null;
  float f = Float.parseFloat(unquote(tok.get(i+2)));
  f = (float) (f+random(-0.1, 0.1));
  tok.set(i+2, quote(str(f)));
  ret join(tok);
}

static BWImage render(Renderer p, BWImage original) {
  ret p.render(original.getWidth(), original.getHeight());
}

static interface Reproducer {
  public S reproduce(BWImage original);
}

static class Solid extends Renderer {
  float col;
  
  BWImage render(int w, int h) {
    ret new BWImage(w, h, col);
  }
}

static class RandomSolid implements Reproducer {
  int n = -1;
  public S reproduce(BWImage original) {
    ++n;
    DynamicObject p = new DynamicObject("Solid");
    if (n % 2 == 0) {
      p.put("col", randomBrightness());
    } else {
      p.put("col", probeRandomPixel(original));
    }
    ret structure(p);
  }
}

static abstract class Renderer {
  abstract BWImage render(int w, int h);
}

static S shortest100() {
  ret loadTextFile(getProgramFile("shortest100.txt"));
}

static BufferedImage renderShortest100() {
  ret render(shortest100());
}

static double getScore(Best b) {
  ret b == null ? 0 : b.score;
}

static S getDesc(Best b) {
  ret b == null ? null : b.desc;
}

static Renderer makeRenderer(S desc) {
  if (rendererMaker != null) {
    Renderer r = cast callF(rendererMaker, desc);
    if (r != null) ret r;
  }
  ret (Renderer) unstructure(desc);
}

static BufferedImage render(S fullDesc) {
  if (fullDesc == null) null;
  new Matches m;
  assertTrue(jmatchStart("* *", fullDesc, m));
  int w = m.psi(0), h = m.psi(1);
  S desc = m.unq(2);
  ret makeRenderer(desc).render(w, h).getBufferedImage();
}