!7

!include early #1033506 // Compact Module Include Gazelle V

module GazelleV > DynPrintLogAndEnabled {
  /*switchable int x1;
  switchable int y1;
  switchable int w = screenWidth();
  switchable int h = screenHeight();*/
  switchable double maxFPS = 10;
  switchable int previewWidth = 200;
  switchable double statsEvery = 5;
  switchable volatile bool brokenMethod;
  int lookAtScreen;
  S previewMode;
  int gridRows = 20;
  bool scaleDownPreviewImage;
  int previewPosterization = 256;
  S uiURL = "Home";
  //bool deepCompression;

  PersistableThrowable lastProcessingError;
  transient WithTimestamp<OKOrError<BufferedImage>> lastScreen;
  transient new Average screenShotTime;
  transient new Average iiTime;
  transient Timestamp loopStarted;
  transient Sleeping screenShotCountdown;
  transient long screenShotCountdownTotalSleepTime;
  //transient ImageSurface imageSurface;
  transient IIImageSurface imageSurface;
  transient Throwable currentProcessingError;
  transient JComponent topControls;
  transient long screenShotsTaken;
  transient double fps;
  transient Compression ongoingCompression, completedCompression;
  transient S longTermCompressionProbability;
  transient S longTermCompressionScore;
  transient JComponent topControls2;
  transient JTabbedPane tabs;
  transient ThreadPool threadPool;
  transient SingleComponentPanel mainArea;
  transient DMPopOutHandler popOutHandler = new {
    void addControl(JComponent c) { GazelleV.this.addControl(c); }
  };
  
  // key:   ui URL
  // value: component maker
  transient Map<S, IF0<JComponent>> uiMap = syncCIMap();
  
  // ping source for everything we do in the background, including
  // analyzing current screen.
  // normally limited to 50% of one core.
  transient PingSource backgroundPingSource;
  
  transient OnOffOscillator onOffOscillator;

  Rect area() {
    ret screenBounds_safe(lookAtScreen);
  }

  class Compression {
    settable BufferedImage image;
    settable BWIntegralImage ii;
    CompressionSearch_AnyType search;
    int baseLineLength; // length of trivial compression
    GridCodec1 codec;
    double compressionPercentage;

    S score() {
      var submission = search?.bestSubmission();
      Int compressedSize = or(submission.compressedSize(), baseLineLength);
      compressionPercentage = 100-doubleRatio(compressedSize, baseLineLength)*100;
      ret iround(compressionPercentage) + "%";
    }

    IProbabilisticScheduler scheduler() {
      ret search?.scheduler();
    }

    S probability() {
      var scheduler = scheduler();
      if (scheduler == null) ret "-";
      var prob = scheduler.lastExecutedProbability();
      ret formatDouble(prob, 3);
    }

    event compressionDone;
      
    run {
      int lHex = pixelCount(image)*8;
      baseLineLength = calculateLengthOfFunctionCall imageFromHex(lHex+2);
      print(+baseLineLength);

      codec = new GridCodec1(image);
      codec.rows = gridRows;
      search = codec.forward();
      //showImage(codec.renderCellsLinearly());

      repeat 60 {
        stepForNSeconds(1, search);
        //print(stepCount := search.scheduler().stepCount());
        setFields(
          longTermCompressionProbability := probability(),
          longTermCompressionScore := score());
      }

      try {
        compressionDone();
        
        L<IJavaExpr> cellCompressions = codec.strat.codeForElements();
        //showText("Compression", lines(map shorten_str(cellCompressions)));

        /*S code = str(codec.winnerCode());
        S name = "Screenshot " + ymdMinusHMS();
        File f = makeFileNameUnique_beforeExtension(
          javaxDataDir("Compressed Screenshots/" + name + ".javax"));
        saveTextFile(f, code);
        printFileInfo(f);          
        saveGZTextFile(f = replaceExtension(f, ".jgz"), code);
        printFileInfo(f);*/

        /*
        print("Evaling " + nChars(code));
        //LL<Int> lol = cast dm_javaEval(code);
        BufferedImage restored = cast dm_javaEval(code);
        assertImagesIdentical(restored, image);
        print("Image restored!");

        dm_showImage("Restored from " + nChars(code), restored);
        */
      } catch e { printStackTrace(e); }
    }
    
    void drawOverlay(ImageSurface is, Graphics2D g) pcall {
      codec.drawOverlay(is, g);
    }
    
    int gridCols() { ret widthForHeight(ii.getWidth(), ii.getHeight(), gridRows); }
  } // end of Compression
  
  int gridCols(MakesBufferedImage ii) { ret widthForHeight(ii.getWidth(), ii.getHeight(), gridRows); }
  
  start {
    if (threadPool == null) threadPool = maxThreadPool();
    
    backgroundPingSource = new PingSource(threadPool, "Background");
    
    onOffOscillator = new OnOffOscillator(backgroundPingSource);
    ownResource(onOffOscillator);
    onOffOscillator.start();
    
    componentFieldsToKeep = litset("tabs");
    
    dm_registerAs_direct gazelleV();
    dm_watchField enabled(r { if (enabled) dm_reload(); });

    // TODO: react to event sent by OS
    
    popOutHandler.start();

    print("Screen bounds: " + allScreenBounds());
    
    initUIMap();
    
    // We are making some UI elements even if the module is hidden
    // because that's easier.
    
    tabs = jtabs(
      "Log", super.visualize(),
      "Local Data", jcenteredlabel("TODO"));

    dm_doEvery(min(statsEvery, 10.0), statsEvery, r { if (enabled) printStats(); });
    
    loopStarted = tsNow();
    shootAndAnalyze();
  }
  
  void shootAndAnalyze {
    backgroundPingSource.do(r shootAndAnalyze_impl);
  }

  void shootAndAnalyze_impl enter {
    if (!enabled) ret;

    var targetTime = tsNow().plus(1.0/maxFPS);
    long time = nanoTime();

    try {
      lastScreen = withTimestamp(okOrError(-> screenshot(area())));
      ++screenShotsTaken;
      setField(fps := doubleRatio(screenShotsTaken, elapsedSeconds(loopStarted)));
      screenShotTime.add(nanosToSeconds(nanoTime()-time));
      time = nanoTime();
      ping();
      if (lastScreen->isOK()) {
        var img = lastScreen!!;
        var ii = BWIntegralImage(img);
        //var ii = BWIntegralImage_luminosity(lastScreen!!);
        iiTime.add(nanosToSeconds(nanoTime()-time));
      
        if (!deepCompression())
          showPreview(ii, null);
        else
          startCompression(ii);
      }
      
      cpuTotal();
      currentProcessingError = null;
    } catch print e {
      setField(lastProcessingError := currentProcessingError = e);
      //sleepSeconds(60); // errors in processing are no good
    }
    
    screenShotCountdown = sleeper().doLater(targetTime, r shootAndAnalyze);
    screenShotCountdownTotalSleepTime += screenShotCountdown.remainingMS();
  }
  
  bool deepCompression() { ret !scaleDownPreviewImage; }
  
  void showPreview(BWIntegralImage ii, Compression completedCompression) {
    IBWIntegralImage ii2 = ii;
    if (scaleDownPreviewImage) {
      ii2 = ScaledIBWIntegralImage(gridCols(ii2), gridRows, ii2);
      ii2 = TruncatedIBWIntegralImage(ii2);
      
      if (previewPosterization < 256)
        imageSurface?.setImage(posterizeIBWImage(previewPosterization, ii2));
      else
        imageSurface?.setImage(ii2);
        
      imageSurface.setOverlay(null);
    } else {
      imageSurface?.setImage(completedCompression.ii, completedCompression.image);
      if (completedCompression != null)
        imageSurface.setOverlay(g -> completedCompression.drawOverlay(imageSurface, g));
    }
  }

  void startCompression(BWIntegralImage ii) {
    if (ongoingCompression == null) {
      ping();
      ongoingCompression = new Compression()
        .image(lastScreen!!)
        .ii(ii);
      ongoingCompression.onCompressionDone(-> {
        completedCompression = ongoingCompression;
        ongoingCompression = null;
        
        showPreview(ii, completedCompression);
      });
      ongoingCompression.run();
    }
  }

  void printStats() { print(stats()); }

  S stats() {
    var screen = lastScreen?!;
    ret formatColonProperties_noNulls(
      "Monitored area", area(),
      "Error", screen?.getError(),
      "Last screenshot taken", lastScreen?.timeStamp(),
      "Average time to take a screenshot", screenShotTime,
      "Average time to make integral image", iiTime,
      "Capacity left in first core", percentRatioStrOneDigit(freeInCore()),
      "Total CPU used", cpuTotal(),
    );
  }

  S cpuTotal() {
    ret setFieldAndReturn(cpuTotal := percentRatioStrOneDigit((1-freeInCore())/numberOfCores()));
  }

  double freeInCore() {
    ret ratio(toSeconds(screenShotCountdownTotalSleepTime),
      elapsedSeconds(loopStarted));
  }

  replace jSection with jCenteredSection.  
  {}
  visualize {
    imageSurface = new IIImageSurface;
    imageSurface.setAutoZoomToDisplay(true);
    setDoubleBuffered(imageSurface, true);
    imageSurface.setPixelated(true);
    imageSurface.noAlpha = true;
    
    var vis = northAndCenterWithMargin(
      withMargin(withLabel("Show",
        comboBoxAndButton(
          onSelectedItem(
            bindComboBoxToLiveValue(centerComboBox(autoComboBox(uiURL, cloneKeys(uiMap))), dm_fieldLiveValue uiURL()),
            url -> showUIURL(url)
          ),
          "Go", url -> showUIURL(url)))),
      mainArea = singleComponentPanel(renderUIUrl(uiURL)));
    setHorizontalMarginForAllButtons(vis, 4);
    ret vis;
  }
  
  BufferedImage lastScreenImage() { ret getVar(getVar(lastScreen)); }

  public bool useErrorHandling() { false; }
  
  JComponent renderUIUrl aka renderUIURL aka uiGet(S url) {
    var maker = uiMap.get(url);
    var component = callF(maker);
    if (component != null) ret component;
    ret jCenteredLabel("URL not found: " + url);
  }
  
  void showUIURL(S url) enter {
    url = trim(url);
    setComponent(mainArea, renderUIUrl(url));
  }
  
  <A extends JComponent> A uiMapPut(S url, IF0<A> maker) {
    uiMap.put(url, -> maker!);
    ret maker!;
  }
  
  void uiPut(S url, IF0<JComponent> maker) {
    uiMap.put(url, maker);
  }
  
  void initUIMap {
    uiPut("FPS", -> jSection("FPS", dm_calculatedCenteredLabel(() -> iround(fps))));

    uiPut("Screen Selector", -> {    
      var screenSelectors = jRadioButtons(
        countIteratorAsList(screenCount(),
          i -> "Screen " + (i+1)));
      selectRadioButton(screenSelectors, lookAtScreen);
      onRadioButtonChange(screenSelectors, i -> { setField(lookAtScreen := i); });
      ret jline(buttonsInGroup(screenSelectors));
    });
    
    uiPut("Screenshot with controls", -> northAndCenterWithMargin(
      topControls2 = /*jflowCenter*/ jPanel(new WrapLayout, flattenList2(
        dm_checkBox enabled(),
        getChildren(renderUIURL("Screen Selector")),
        dm_spinnerWithLabel gridRows("Rows", 1, 500),
        dm_checkBox("Scale down", "scaleDownPreviewImage"),
        dm_spinnerWithLabel previewPosterization("Posterize", 2, 256)
      )),
      jscroll_center(imageSurface)));
      
    uiPut("Enabled", -> dm_checkBox enabled());

    uiPut("Home", ->
      hsplit(northAndCenterWithMargin(
        topControls = hgrid(
          renderUIUrl("FPS"),
          jSection("Compression", dm_centeredFieldLabel longTermCompressionScore()),
          //jSection("Probability", dm_centeredFieldLabel longTermCompressionProbability()),
          jSection("CPU (" + numberOfCores() + ")", dm_centeredFieldLabel cpuTotal())
        ),
        tabs),
        renderUIUrl("Screenshot with controls")
      ));
  }
} // end of module

Began life as a copy of #1033526