// WELCOME!! This is THE PROGRAM YOU ARE LOOKING FOR.

!7

lib 1400521 // FlatLAF

set flag PingV3.
set flag NotifyingPrintLog.

// Do the JavaX init
svoid standaloneInit {
  __javax = x30.class;
  x30.__javax = x30.class; // for hotwire
  x30_pkg.x30_util.__setJavaX(x30.class);
  x30.cleanKillMsg = "";
  callOnLoadMethods(mc());
}

sclass GazelleHost {
  S windowTitle = "November Gazelle v.5";
  S downloadURL = "https://botcompany.de/jar/" 
    + psI(programID()) + "?withLibs=1&noCompiler=1";
  sS trayIconImageID = #1103047;
  int borderSize = 5;
  Color color1 = awtColor("ADD8E6");
  Color color2 = awtColor("EEEEEE");
  Color color3 = awtColor("A3C0AA");
  IF0<DynModule> moduleMaker;
  ThreadPool threadPool;
  
  *(ThreadPool *threadPool, IF0<DynModule> *moduleMaker) {}

  class Stem {
    JFrame window;
    
    Rect getFrameRect() {
      ret toRect(getBounds(window));
    }
  }
  
  Stem stem;
  DynModule gazelle;
  TrayIcon trayIcon;
  JFrame mainWindow;
  Set<S> argsSet;
  
  void trayIconLeftClick {
    activateFrame_v3(mainWindow);
  }
  
  void makeTrayIcon {
    pcall-short {
      trayIcon_imageAutoSize = false;
      trayIcon = installTrayIcon(trayIconImageID, windowTitle,
        r trayIconLeftClick,
        "Show Gazelle", r { activateFrame(mainWindow) },
        "Exit Gazelle", r cleanExit
      );
    }
  }
  
  void run(S[] args) {
    argsSet = asSet(args);
    
    if (!argsSet.contains("noflatlaf"))
      com.formdev.flatlaf.FlatLightLaf.setup();
    
    if (contains(args, "profile"))
      profileToConsole(() -> actualMain(args));
    else
      actualMain(args);
      
    if (argsSet.contains("brexit")) System.exit(0);
  }
  
  void actualMain(S... args) {
    vm_generalMap_put(stefansOS := this);
    
    System.out.println(hmsWithColonsAndMS() + ": Init");
    //x30.coreInit();
    
    // Ready to roll
    
    if (containsOneOf(argsSet, "upgrade", "update"))
      ret with upgradeGazelle();
  
    makeTrayIcon();
    
    makeModule();
    
    stem = new Stem;
    gazelle._host = stem;
    copyLocalLog(gazelle, mc());
  
    JComponent vis;
    {
      temp gazelle.enter();
      gazelle.start();
    
      printWithMS("Visualize");
      vis = swing(-> {
        temp gazelle.enter();
        ret gazelle.visualize();
      });
    }
    
    vis = makeWindowBorderAndTitle(vis, windowTitle);
    printWithMS("Show frame");
    //stem.window = showMainFrame("Gazella", vis);
    JFrame frame = makeUndecoratedFrame(windowTitle, vis);
    setFrameIcon(frame, trayIconImageID);
    stem.window = mainWindow = frame;
    onWindowClosing(stem.window, r cleanExit);
    showWindow(stem.window);
    printWithMS("Dudadoneski");
  }
  
  void minimize {
    if (trayIcon == null)
      minimizeWindow(mainWindow);
    else
      hideWindow(mainWindow);
  }  
  
  JComponent makeWindowBorderAndTitle(JComponent contents, S title) {
    //ret jCenteredSection_fontSizePlus(10, title, vis);
    
    var icons = jline();
    icons.add(jbutton("Minimize", r minimize));
    icons.add(jbutton("Close", r { disposeWindow(icons) }));
    icons.add(jPopDownButton_noText(
      "Update Gazelle", rThread upgradeGazelle,
      "Dump threads", rThread { showText("User threads", renderUserThreadsWithStackTraces()); },
    ));
    
    var actualTitle = fontSizePlus(7, jCenteredLabel(title));
    var spacer = gazelle_wavySpacer();
    var titleBarMain = setOpaqueBackground(color1,
      westCenterAndEastWithMargin(
        jImage_scaledToHeight(24, trayIconImageID),
        actualTitle,
        setOpaqueBackground(color2, spacer));
    
    installWindowDragger(actualTitle);
    installWindowDragger(spacer);
    
    var titleBar = setBackground(color2, centerAndEast(
      titleBarMain,
      icons));
    
    var border =
      // createBevelBorder();
      BorderFactory.createLineBorder(color1, borderSize);
      
    var outerPanel = withBorder(border,
      northAndCenter(titleBar, contents));
      
    installWindowResizeDraggerOnBorder(outerPanel);
    ret outerPanel;
  }
  
  O dm_getStem(O moduleOrID) {
    ret stem;
  }
  
  O resolveModule(O moduleOrID) { ret moduleOrID == stem ? gazelle : moduleOrID; }
  
  void cleanExit {
    System.exit(0);
  }
  
  void upgradeGazelle {
    File myJar = getBytecodePathForClass(this);
    print(+myJar);
    
    S javaCmd = or2(currentProcessCommand(), "java");
    S date = ymdMinusHMS();
    File f = javaxCodeDir("Downloaded Updates/" + "gazelle-" + date + ".jar");
    infoBox("Downloading Update...");
    loadBinaryPageToFile(downloadURL, f);
    printFileInfo(f);
    if (!isNonEmptySingleZip_byMagicHeader(f))
      ret with  infoBox("Bad file downloaded... :(");
      
    bool replaced;
    if (isFile(myJar)) {
      print("Loaded " + nClasses(loadAllClassesInByteCodePath(myJar)));
      print("Replacing with new version: " + myJar);
      renameFile(myJar, appendToBaseName(myJar, ".bak." + date));
      copyFile(f, myJar);
      printFileInfo(myJar);
      set replaced;
    }
      
    infoBox(replaced
      ? "Installed update, replaced " + f2s(myJar) + " - now starting"
      : "Starting update, but could not replace originally downloaded jar");
    S cmd = pqO(javaCmd) + " -jar " + pqO(replaced ? myJar : f);
    print(cmd);
    nohup(cmd);
    cleanExit();
  }
  
  void makeModule() {
    if (gazelle == null)
      gazelle = callF(moduleMaker);
  }
}

!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;

  PersistableThrowable lastProcessingError;
  transient WithTimestamp<OKOrError<BufferedImage>> lastScreen;
  transient new Average screenShotTime;
  transient new Average iiTime;
  transient Timestamp loopStarted;
  transient new RestartableCountdown screenShotCountdown;
  //transient ImageSurface imageSurface;
  transient IIImageSurface imageSurface;
  transient Throwable currentProcessingError;
  transient BufferedImage previewImage;
  transient JButton popDownButton;
  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;

  Rect area() {
    ret screenBounds(min(lookAtScreen, screenCount()-1));
  }

  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 = doubleRatio(compressedSize, baseLineLength)*100;
      ret formatDouble(compressionPercentage, 3) + "%";
    }

    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());

      thread "Gazelle Visual" {
        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);
    }
  }
  
  start {
    componentFieldsToKeep = litset("tabs");
    
    dm_registerAs_direct gazelleV();
    dm_watchField enabled(r { if (enabled) dm_reload(); });

    // TODO: react to event sent by OS
    dm_doEvery(1.0, r {
      if (dm_moduleIsPoppedOut()) adjustUIForPoppedOutWindow();
    });
    
    print("Screen bounds: " + allScreenBounds());
    
    // 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(); });
    
    threadPool.do("Start Loop", rEnter {
      ping();
      loopStarted = tsNow();
      shoot();
    });
  }

  void shoot enter {
    if (!enabled) ret;
    
    long targetTime = sysNow()+iround(1000/maxFPS);
    long time = nanoTime();

    try {
      lastScreen = withTimestamp(okOrError(-> screenshot(area())));
      ++screenShotsTaken;
      setField(fps := doubleRatio(screenShotsTaken, elapsedSeconds(loopStarted)));
      screenShotTime.add(nanosToSeconds(nanoTime()-time));
      time = nanoTime();
      if (lastScreen->isOK()) {
        var img = lastScreen!!;
        var ii = BWIntegralImage(img);
        //var ii = BWIntegralImage_luminosity(lastScreen!!);
        iiTime.add(nanosToSeconds(nanoTime()-time));
      
        if (eq(previewMode, "showLatestGrabbed"))
          imageSurface?.setImage(ii, img);

        if (ongoingCompression == null)
          startCompression(ii);
      }
      
      cpuTotal();
      currentProcessingError = null;
    } catch print e {
      setField(lastProcessingError := currentProcessingError = e);
      sleepSeconds(60); // errors in processing are no good
    }
    
    screenShotCountdown.setTargetTime(targetTime, r shoot);
  }

  void startCompression(BWIntegralImage ii) {  
    if (ongoingCompression == null) {
      ongoingCompression = new Compression()
        .image(lastScreen!!)
        .ii(ii);
      ongoingCompression.onCompressionDone(-> {
        completedCompression = ongoingCompression;
        ongoingCompression = null;
        
        imageSurface?.setImage(completedCompression.ii, completedCompression.image);
        imageSurface.setOverlay(g -> completedCompression.drawOverlay(imageSurface, g));
      });
      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(screenShotCountdown.totalSleepTime),
      elapsedSeconds(loopStarted));
  }

  replace jSection with jCenteredSection.  
  {}
  visualize {
    imageSurface = new IIImageSurface;
    setDoubleBuffered(imageSurface, true);
    imageSurface.noAlpha = true;
    
    var screenSelectors = jRadioButtons(
      countIteratorAsList(screenCount(),
        i -> "Screen " + (i+1)));
    onRadioButtonChange(screenSelectors, i -> { lookAtScreen = i; });
    
    ret hsplit(northAndCenterWithMargin(
      topControls = hgrid(
        jSection("FPS", dm_calculatedCenteredLabel(() -> iround(fps))),
        jSection("Compression", dm_centeredFieldLabel longTermCompressionScore()),
        jSection("Probability", dm_centeredFieldLabel longTermCompressionProbability()),
        jSection("CPU (" + numberOfCores() + ")", dm_centeredFieldLabel cpuTotal())
      ),
      tabs),
      northAndCenterWithMargin(
        topControls2 = jCenteredLine(listPlus(wideningListCast Component(buttonsInGroup(screenSelectors)),
          dm_spinnerWithLabel gridRows(1, 500))),
        jscroll_center(imageSurface)));
  }
  
  BufferedImage lastScreenImage() { ret getVar(getVar(lastScreen)); }

  void adjustUIForPoppedOutWindow swing {
    if (popDownButton == null) {
      Window window = cast getWindow(dm_vis());

      var popBackInButton = findButton(window, "Pop Back In");
      var parent = getParent(popBackInButton);
      print(+parent);
      
      removeFromParent(parent); // hide controls
      
      popDownButton = jPopDownButton_noText(
        "Pop Back In", r { dm_popInModule(me()) },
        jCheckBoxMenuItem("Always On Top", isAlwaysOnTop(window),
          rEnter dm_toggleAlwaysOnTop),
      );
      addControl(popDownButton);      
    }
  }
  
  public bool useErrorHandling() { false; }
}

sS windowTitle = "November Gazelle v1";
sS progIDForAutoUpdate = #1033525;
sbool pingSourceStrictMode;

static GazelleHost host;
static GazelleV client;
static ThreadPool threadPool;

p {
  loadableUtils.utils.__setJavaX(x30.class);
  standaloneInit();
  
  ping_v3_setPingSourceMaker(-> {
    System.out.println("pingSourceMaker");
    if (pingSourceStrictMode)
      fail("Strict mode - make a ping source first!!");
    ret new PingSource(threadPool, "legacy");
  });
  
  threadPool = new ThreadPool(findIntArg cores(args, numberOfCores()));
  print(threadPool);
  threadPool.verbose = true;
  PingSource ps = new(threadPool, print("Starting Gazelle"));
  ps.do(-> {
    System.out.println("Pinging");
    ping();
    //if (true) fail("error test");
  
    print("Pinged");
    
    programID = progIDForAutoUpdate;
      
    host = new GazelleHost(threadPool, -> {
      new GazelleV g;
      g.threadPool = threadPool();
      ret client = g;
    });
    host.windowTitle = windowTitle;
    host.run(args);
  });
  print("aha.");
}