lib 1400521 // FlatLAF

set flag PingV3.

set flag NotifyingPrintLog.

set flag SymbolAsString.

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

}

concept PrintLogModule > DynPrintLog {

  start { setModuleName("Log"); }

  S getPrintLog() {

    ret printLog();

  }

  bool useErrorHandling() { false; }

}

concept Stem {

  transient GazelleHost host;

  DynModule module;

  Rect frameRect;

  bool minimized, maximized, alwaysOnTop, autoUpdate, minimizeToTray;

  LS fieldsToShareBetweenDatabases() {

    ret identifiers("frameRect, minimized, maximized, alwaysOnTop, autoUpdate, minimizeToTray");

  }

  transient JFrame window;

  transient JButton btnMax;

  transient JLabel titleComponent;

  transient gettable JButton compileButton;

  //transient bool autoUpdateDisabled;

  *() {}

  *(GazelleHost *host) {}

  *(GazelleHost *host, DynModule *module) {}

  Rect getFrameRect() {

    ret toRect(getBounds(window));

  }

  void saveFrameRect {

    setField(frameRect := getFrameRect());

  }

  void setAlwaysOnTop(bool alwaysOnTop) {

    this.alwaysOnTop = alwaysOnTop;

    change();

    alwaysOnTop(window, alwaysOnTop);

  }

  void setMinimizeToTray(bool minimizeToTray) {

    cset(this, +minimizeToTray);

  }

  void setWindow(JFrame window) {  

    this.window = window;

    if (frameRect != null)  

      setBounds(window, frameRect);

    //onWindowClosing(window, -> host.cleanExit());

    onBoundsChange(window, r saveFrameRect);

    alwaysOnTop(window, alwaysOnTop);

  }

  void activateWindow {

    activateFrame_v3(window);

  }

  bool isMain() { ret this == host.stem; }

  void minimize {

    cset(this, minimized := true);

    if (!minimizeToTray || host.trayIcon == null || !isMain())

      minimizeWindow(window);

    else

      hideWindow(window);

  }

  void deleteMe {

    printAlsoToSystemOut = true;

    print("deleteMe " + isMain());

    if (isMain()) {

      host.cleanExit();

    } else {

      cleanMeUp();

    }

  }

  void cleanMeUp {

    disposeWindow(window);

    dispose module;

    cdelete(this);

  }

  void grabWindowState {

    setField(maximized := !isExtendedStateNormal(window));

  }

  void updateBtnMax {

    if (!isShowing(btnMax)) ret;

    grabWindowState();

    setText(btnMax, maximized ? "NORM" : "MAX");

  }

  JComponent makeWindowBorderAndTitle(JComponent contents, S title) {

    //ret jCenteredSection_fontSizePlus(10, title, vis);

    var icons = jline();

    if (host.allowFrameMaximization) {

      icons.add(btnMax = jbutton("", rThread {

        maximizeOrRestoreFrame(window);

        updateBtnMax();

      }));

      onFirstShowing(btnMax, r updateBtnMax);

    }

    icons.add(toolTip("Minimize this window", jbutton("MIN", r minimize)));

    if (isMain())

      icons.add(toolTip("Exit Gazelle", jbutton("QUIT", rThread {

        if (swingConfirm(window, "Really quit Gazelle?"))

          deleteMe();

      })));

    else

      icons.add(toolTip("Close this window", jbutton("X", rThread deleteMe)));

    //setHorizontalMarginForAllButtons(icons, 4);

    icons.add(jPopDownButton_noText(flattenToList(

      // always on top

      jCheckBoxMenuItem_dyn("Always on top",

        -> alwaysOnTop,

        alwaysOnTop -> setAlwaysOnTop(alwaysOnTop)),

      // restart + update

      "---",

      "Restart", rThread { host.restart() },

      "Update Gazelle", rThread { host.upgradeGazelle() },

      !isMain() ? null : jCheckBoxMenuItem_dyn("Auto-Update",

        -> autoUpdate,

        b -> cset(Stem.this, autoUpdate := b)),

      // debugging + screenshooting gazelle

      "---",

      !isMain() ? null : ll(

        "Screenshoot this window", rThread shootWindow,

        "Dump threads", rThread { showText("User threads", renderUserThreadsWithStackTraces()); },

        !isMain() ? null : "Log", !isMain() ? null : r { host.showPrintLog() },

        !isMain() ? null : "Copy log to clipboard", !isMain() ? null : rThread {

          copyToClipboard(printLog());

          infoBox("Copied log to clipboard");

        },

      ),

      ccallOpt(module, "popDownItems")

    )));

    JComponent actualTitle = titleComponent = fontSizePlus(7, jCenteredLabel(title));

    installWindowDragger(actualTitle);

    if (/*isMain() &&*/ haveMuricaPassword())

      actualTitle = centerAndEastWithMargin(actualTitle,

        jline(

          compileButton = makeCompileButton(),

          jLiveValueLabel(host.lvComputerCount())

        ));

    var spacer = gazelle_wavySpacer();

    var titleBarMain = setOpaqueBackground(host.color1,

      jtransparent_recursive(westCenterAndEastWithMargin(

        jImage_scaledToHeight(24, host.trayIconImageID),

        actualTitle,

        setOpaqueBackground(host.color2, spacer)));

    installWindowDragger(spacer);

    var titleBar = setBackground(host.color2, centerAndEast(

      titleBarMain,

      icons));

    var border =

      // createBevelBorder();

      BorderFactory.createLineBorder(host.color1, host.borderSize);

    var outerPanel = withBorder(border,

      northAndCenter(titleBar, contents));

    installWindowResizeDraggerOnBorder(outerPanel);

    ret outerPanel;

  }

  JButton makeCompileButton() {

    var gears = resizeImageIcon(imageIcon(#1103061), 16);

    var btn = jimageButtonScaledToWidth(16, #1101268, "Compile & update",

      rThread { host.compile() });

    //enableComponentAccordingToVar(host.compileButtonEnabled, btn);

    componentPopupMenuItem(btn, "Compile main library", rThread { host.compileUtils() });

    ret btn;

  }

  void startAndShow() {

    module._host = this;

    setOpt_raw(module, +threadPool); // only if the field exists

    setOpt_raw(module, concepts := host.concepts);

    setOpt_raw(module, g22utils := host.g22utils);

    copyLocalLog(module, mc());

    var vis, title = unpair makeVisAndTitle();

    printWithMS("Show frame");

    JFrame frame = makeUndecoratedFrame(title, vis);

    setFrameIcon(frame, host.trayIconImageID);

    setWindow(frame);

    frame.addPropertyChangeListener("title", evt ->

      setText(titleComponent, frame.getTitle()));

    if (minimized) minimize();

    onWindowDeiconified(frame, -> cset(this, minimized := false));

    showWindow(window);

    if (maximized && host.allowFrameMaximization) maximizeFrame(window);

  }

  Pair<JComponent, S> makeVisAndTitle() {

    JComponent vis;

    {

      printWithMS("Starting " + module);

      temp module.enter();

      module.start();

      printWithMS("Visualize");

      vis = swing(-> {

        temp module.enter();

        ret module.visualize();

      });

    }

    S title = host.windowTitle;

    if (!isMain())

      // title += appendWithColon(module.moduleName());

      title = unnull(module.moduleName());

    vis = makeWindowBorderAndTitle(vis, title);

    ret pair(vis, title);

  }

  void revisualize {

    if (window == null) ret;

    pcall {

      module.unvisualize();

    }

    var vis, title = unpair makeVisAndTitle();

    setFrameContents(window, vis);

  }

  void shootWindow {

    var img = renderComponentToImage(window);

    copyImageToClipboard(img);

    saveInImageDirectoryWithCounter(gazelle22_imagesSubDirName() + "/Gazelle", img);

  }

} // end of Stem

// This replaces the Stefan's OS main class. It is not persisted

transient sclass GazelleHost is G22MasterStuff {

  Stem stem;

  DynModule gazelle;

  transient S windowTitle = "November Gazelle v1";

  transient S trayIconImageID = #1103047;

  transient int borderSize = 5;

  transient Color color1 = awtColor("ADD8E6");

  transient Color color2 = awtColor("EEEEEE");

  transient Color color3 = awtColor("A3C0AA");

  transient IF0<DynModule> moduleMaker;

  transient ThreadPool threadPool;

  transient TrayIcon trayIcon;

  transient TrayIconLastPosition trayIconLastPosition;

  transient Set<S> argsSet;

  transient bool incrementalDownloads = true;

  transient Concepts concepts;

  // This caused problems, disabled for now

  transient bool allowFrameMaximization;

  transient StefansOS_ConnectToServer serverConnector;

  transient ComputerCountListener computerCount;

  transient Q systemQ = startQ("System Q");

  //transient BoolVarWithNotify compileButtonEnabled = new(true);

  transient new G22Utils g22utils;

  transient MapSO importedFieldsForMainStem;

  *(ThreadPool *threadPool, IF0<DynModule> *moduleMaker) {}

  void trayIconLeftClick {

    activateFrame_v3(mainWindow());

  }

  void makeTrayIcon {

    pcall-short {

      trayIcon_imageAutoSize = false;

      trayIcon = installTrayIcon(trayIconImageID, windowTitle,

        r trayIconLeftClick,

        "Show Gazelle", r trayIconLeftClick,

        "Exit Gazelle", r cleanExit

      );

      trayIconLastPosition = new TrayIconLastPosition(trayIcon);

    }

  }

  void run(S[] args) {

    try {

      run2(args);

    } catch print e {

      //messageBox(e);

      hideTrayIcon(trayIcon);

      onWindowClosing(-> systemExit(1), getWindow(

        showText_fast_noWrap("Gazelle Error", renderStackTrace(e))));

      //AutoVMExit.install();

    }

  }

  void run2(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

    printJavaVersion();

    if (contains(argsSet, "profile"))

      doEvery(1.0, r printRunningThreads);

    if (containsOneOf(argsSet, "upgrade", "update"))

      ret with upgradeGazelle();

    g22utils.masterStuff = this;

    makeTrayIcon();

    initAutoUpdate();

    IF1<S, Class> classFinder = makeClassFinder();

    // Start DB

    S dbName = g22utils.dbToOpen();

    File conceptsFile = newFile(newFile(g22utils.databasesMotherDir(), dbName), conceptsFileName());

    concepts = newConceptsWithClassFinder(conceptsFile, classFinder);

    startDBAndModules();

  }

  void startDBAndModules {

    concepts.makeStructureData = -> {

      structure_Data data = concepts.makeStructureData_base();

      data.mcDollar = mcDollar();

      ret data;

    };

    try {

      concepts.fileLock().lockOrFail();

    } catch print e {

      if (cic(str(e), "Couldn't aquire lock")) {

        infoBox("Gazelle is still running, please exit it first!", 10.0);

        sleepSeconds(10);

        System.exit(1);

      }

    }

    concepts.fileLock().deleteOnExit();

    concepts.persist();

    //db_setMainConcepts(concepts);

    //print("Concepts loaded: " + map className(allConcepts(concepts));

    var stems = findConcepts(concepts, Stem);

    print("Stems in DB: " + l(stems));

    stem = first(stems);

    if (stem == null) {

      print("Starting new module");

      makeModule();

      stem = registerConcept(concepts, new Stem(this, gazelle));

    }

    gazelle = stem.module;

    print(+importedFieldsForMainStem);

    csetAll(stem, importedFieldsForMainStem);

    importedFieldsForMainStem = null;

    for (stem : list Stem(concepts)) {

      stem.host = this;

      stem.startAndShow();

    }

    printWithMS("Dudadoneski");

  }

  void showPrintLog {

    systemQ.add(-> {

      var logModule = firstThat(list(concepts, Stem),

        stem -> stem.module instanceof PrintLogModule);

      if (logModule != null)

        logModule.activateWindow();

      else

        registerConcept(concepts, new Stem(this, new PrintLogModule)).startAndShow();

    });

  }

  JFrame mainWindow() {

    ret stem?.window;

  }

  O dm_getStem(O moduleOrID) {

    ret stem;

  }

  O resolveModule(O moduleOrID) { ret moduleOrID == stem ? gazelle : moduleOrID; }

  void cleanExit {

    // e.g. JPaintTool does clean-up when removed (through bindToComponent)

    /*print("Removing all components");

    for (window : allWindows())

      setWindowContents(window, jcenteredlabel("Exiting..."));*/

    print("Saving DB for exit");

    dispose concepts;

    System.exit(0);

  }

  File myJar() { ret getBytecodePathForClass(this); }

  AutoCloseable tempDisableCompileButtons() {

    ret tempDisableButtons(compileButtons());

  }

  void upgradeGazelle {

    try {

      printAlsoToSystemOut = true;

      // Show an infoBox to make sure the code for infoBox is loaded

      temp tempInfoBox("Updating Gazelle...");

      //temp tempSetBoolVar(compileButtonEnabled, false);

      temp tempDisableCompileButtons();

      for (f : allJFrames()) setFrameTitle(f, "Updating...");

      File myJar = myJar();

      print(+myJar);

      S existingFilesComp = !incrementalDownloads ? null

        : existingFilesInfo();

      S date = ymdMinusHMS();

      File f = javaxCodeDir("Downloaded Updates/" + "gazelle-" + date + ".jar");

      temp progress = tempProgressBar_addToWindowIfPossible(mainWindow(), "Updating Gazelle");

      progress.setText("Downloading Update...");

      time "Downloading zip" {

        postBinaryPageToFile(downloadURL(), f, +existingFilesComp);

      }

      printFileInfo(f);

      if (!isNonEmptySingleZip_byMagicHeader(f))

        ret with infoBox("Bad file downloaded... :(");

      bool replaced;

      if (isFile(myJar)) {

        // load all my classes to be sure (TODO: could do this in parallel to downloading)

        //print("Loaded " + nClasses(loadAllClassesInByteCodePath(myJar)));

        progress.setText("Replacing with new version: " + renderFileInfo(myJar));

        File myJarSaved = fileInSubDir("old-code",

          appendToBaseName(myJar, ".bak." + date));

        File myJarNew = appendToFileName(myJar, ".new");

        Set<S> toKeep = asSet(tlft(loadTextFileFromZip(f, "to-keep")));

        if (nempty(toKeep)) {

          progress.setText("Keeping " + nFiles(toKeep));

          int have = countFilesInZip(myJar);

          if (l(toKeep) == have && countFilesInZip(f) == 1) {

            infoBox("Nothing to update - will just restart");

            deleteFile(myJarNew);

            sleepSeconds(1);

            restart();

          }

          /*

          temp ZipOutputStream out = zipOutputStream(myJar);

          zip2zip_withPredicate(myJarSaved, out, name -> toKeep.contains(name));

          progress.setText("Adding new files");

          int n = zip2zip_withPredicate(f, out, name -> !eq(name, "to-keep"));

          progress.setText("Added " + nFiles(n));

          */

          temp Zip4j_MergeZipFilesWithFilter merger = new(myJarNew);

          merger.addZipFile(myJar, name -> contains(toKeep, name));

          merger.addZipFile(f, name -> !eq(name, "to-keep"));

          merger.finish();

        } else

          myJarNew = f;

        if (isWindows()) {

          copyFileVerbose(myJar, myJarSaved);

          copyFileVerbose(myJarNew, myJar);

          deleteFileVerbose_assertSuccess(myJarNew);

        } else {

          renameFileVerbose_assertSuccess(myJar, myJarSaved);

          renameFileVerbose_assertSuccess(myJarNew, myJar);

        }

        printFileInfo(myJar);

        set replaced;

      }

      progress.setText("Done");

      if (replaced)

        infoBox("Installed update, replaced " + f2s(myJar) + " - now starting");

      else

        infoBox("Updated but could not replace originally downloaded jar");

      restart(replaced ? myJar : f);

    } on fail e { printStackTrace(e); }

  }

  void restart(File jar default myJar()) {

    S javaCmd = or2(currentProcessCommand(), "java");

    S cmd = pqO(javaCmd) + " -jar " + pqO(jar);

    print(cmd);

    nohup(cmd);

    cleanExit();

  }

  void makeModule() {

    if (gazelle == null)

      gazelle = callF(moduleMaker);

  }

  void reloadModuleInBackground(Stem mod) {

    restart();

  }

  void initAutoUpdate {  

    print("Making server connection for updates.");

    serverConnector = snippetUpdateConnector(/*verbose := true*/);

    //serverConnector.verbose = true;

    vmBus_onMessage snippetUpdate(voidfunc(L l) {

      S uri = getString(l, 1);

      new Matches m;

      if (swic(uri, "/transpileOK/", m))

        if (sameSnippetID(programID(), firstIntAsString(m.rest()))) {

          if (stem.autoUpdate /*&& autoUpdateDisabled*/)

            upgradeGazelle();

          //infoBox("Gazelle can be updated!");

        }

    });

    pcall {

      computerCount = new ComputerCountListener(serverConnector);

      computerCount.init();

    }

  }

  S downloadURL() {

    ret "https://botcompany.de/jar/" 

      + psI(programID()) + "?withLibs=1&withX30=1"

      + "&mainClassForManifest=Starter"

      + (!downloadJarWithSrc() ? "&noSrc=1" : "")

      + (downloadUncompressedJAR() ? "&uncompressed=1" : "");

  }

  bool downloadJarWithSrc() { false; }

  bool downloadUncompressedJAR() { false; }

  // called by DynModule

  void revisualizeModule(Stem stem) {

    stem.revisualize();

  }

  Int computerCount() { ret computerCount == null ? (Int) 0 : computerCount!; }

  LiveValue<Int> lvComputerCount() { ret computerCount.liveValue(); }

  L<JButton> compileButtons() { ret mapNonNulls(list(Stem), s -> s.compileButton()); }

  // compile main program

  void compile {

    compile(programID, null);

  }

  void compileUtils {

    compile(utilsSnippetID(), l0 compile);

  }

  void compile(S snippetID, Runnable onSuccess) {

    print("Compiling " + snippetID);

    var gears = resizeImageIcon(imageIcon(#1103061), 16);

    temp tempDisableCompileButtons();

    temp tempSetButtonImages(compileButtons(), gears);

    thread { existingFilesInfo(); } // precompute

    transpileOnServerWithErrorWindow(snippetID, true, onSuccess);

    print("Done transpilation of " + snippetID);

  }

  public void switchDatabase(File conceptsDir) {

    printAlsoToSystemOut = true;

    temp tempInfoBoxNoHide("Switching database...");

    // copy some things that should really be global

    // like auto-update flag and main window position

    importedFieldsForMainStem = cgetAll(stem, stem.fieldsToShareBetweenDatabases());

    print(+importedFieldsForMainStem);

    File newConceptsFile = newFile(conceptsDir, conceptsFileName());

    if (!fileExists(newConceptsFile))

      fail(infoBox("Database not found: " + newConceptsFile));

    print("Cleaning up concepts");

    for (Concept c : allConcepts(concepts))

      cleanUp(c);

    print("Releasing DB");

    gazelle = null;

    dispose concepts;

    //print("Safety sleep (1s)");

    //sleepSeconds(1);

    var classFinder = makeClassFinder();

    print("Loading new DB: " + f2s(newConceptsFile));

    concepts = newConceptsWithClassFinder(newConceptsFile, classFinder);

    startDBAndModules();

    g22utils.openedDB(conceptsDir);

    print("Database switch complete, stopping System.out");

    printAlsoToSystemOut = false;

  }

  IF1<S, Class> makeClassFinder() {  

    IF1<S, Class> defaultClassFinder = toIF1(_defaultClassFinder());

    IF1<S, Class> classFinder = name -> {

      // class migration

      if (eq(name, "main$G22RecognizerScript")) {

        S newName = "main$G22Analyzer";

        print("Migrating legacy class " + name + " to " + newName);

        name = newName;

      }

      ret defaultClassFinder.get(name);

    };

    // Test classFinder sanity

    assertEquals(callF(classFinder, "main$Stem"), Stem.class);

    ret classFinder;

  }

  transient cached S existingFilesInfo() {

    L<Map> fingerprints =  zipFileToJSONFingerprint_md5(myJar());

    S s = base64encode(gzipString(jsonEncode(fingerprints)));

    print(existingFilesInfo := nBytes(l(s)));

    ret s;

  }

} // end of GazelleHost