!752

static BWImage bw;
static ImageSurface imageSurface;
static Reproducer reproducer;
static int pivotLength = -1; // no length punishment at start
static int pivotStep = 1;
static int maxQueueLength = 10;

static new LinkedBlockingQueue<S> newProducts;
static double bestScore;
static volatile S bestDesc;
static BWImage bestRendering;
static Thread producer;

!include #1000522 // image helper functions

p {
  bw = loadBWImage("#1004541");
  imageSurface = showImage(bw.getBufferedImage());
  
  showImage("Full Grab", descToImage(fullGrab(bw)));
  
  produce();
  
  reproduceOpenEnd(bw, imageSurface);
  
  while (solved()) {
    pivotLength = l(bestDesc) - pivotStep;
    print("Trying pivot length " + pivotLength);

    reproduceOpenEnd(bw, imageSurface);
  }
}

static void produce() {
  cancelThread(producer);
  producer = new Thread(r {
    // STRATEGY!
    
    push(fullGrab(bw));
    int w = 1;
    while licensed {
      push(new RandomSolid().reproduce(bw));
      S best = bestDesc;
      if (best != null)
        push(varyFloat(best));
      if (w+1 < bw.getWidth())
        push(hrepeat(bw, w++));
    }
  }, "Producer");
  producer.start();
}

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 void push(S product) {
  if (product == null) ret;
  while (newProducts.size() >= maxQueueLength && mayRun())
    sleep(100);
  newProducts.add(product);
}

static BufferedImage descToImage(S desc) {
  try {
    ret makeRenderer(desc).render(bw.getWidth(), bw.getHeight()).getBufferedImage();
  } catch {
    fail(desc);
  }
}

static double formula(S desc, double pixelScore) {
  int lengthPunishment = pivotLength < 0 ? 0
    : max(0, l(desc)-pivotLength);
  ret pixelScore-lengthPunishment;
}

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 void reproduceOpenEnd(BWImage original, ImageSurface imageSurface) {
  bestDesc = null;
  bestScore = 0;
  bestRendering = null;
  Renderer best = null;
  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)
        System.out.println(s);
      else {
        System.out.println("Best: " + bestDesc);
        System.out.println(s + ", score: " + formatDouble(bestScore, 2) + "%, structure size: " + structureSize(best, Renderer.class));
      }
    }
    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, original);
    double pixelScore = 100*(1-diff(original, rendering));
    double score = formula(desc, pixelScore);
    
    if (bestDesc == null || p != null && score > bestScore) {
      //System.out.println("New best! " + score);
      bestDesc = desc;
      bestScore = score;
      bestRendering = rendering;
      best = p;
      imageSurface.setImage(bestRendering.getBufferedImage());
    }
    
    if (solved()) {
      print("Solved! l=" + l(bestDesc));
      print(bestDesc);
      break;
    }
  }
}

sbool solved() {
  ret bestScore >= 100.0;
}

static Renderer makeRenderer(S desc) {
  ret (Renderer) unstructure(desc);
}

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 = makeRenderer(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 BWImage render(Renderer p, BWImage original) {
  ret p.render(original.getWidth(), original.getHeight());
}