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 extends ConceptWithChangeListeners is AutoCloseable {
  transient GazelleHost host;
  transient LoadedDB db;
  DynModule module;
  settableWithVar Rect frameRect;
  bool minimized, maximized, alwaysOnTop, minimizeToTray;
  
  transient JFrame window;
  transient JButton btnMax;
  transient JLabel titleComponent;
  transient gettable JButton compileButton;
  //transient bool autoUpdateDisabled;
  transient bool started;

  *() {}
  *(LoadedDB *db) { host = db.host; }
  *(LoadedDB db, DynModule *module) { this(db); }
  
  transient Component selfVis; // how the module visualized itself
  
  // Not sure why we use LazyVar here instead of simplyCached
  
  transient LazyVar<SingleComponentPanel> scpMainWindowContents = new(-> scp());
  SingleComponentPanel scpMainWindowContents() { ret scpMainWindowContents!; }

  transient LazyVar<SingleComponentPanel> scpMainWindowWithTitle = new(-> scp());
  SingleComponentPanel scpMainWindowWithTitle() { ret scpMainWindowWithTitle!; }

  transient LazyVar<SingleComponentPanel> scpFrameIcon = new(-> scp());
  SingleComponentPanel scpFrameIcon() { ret scpFrameIcon!; }

  Rect grabFrameRect() {
    ret toRect(getBounds(window));
  }
  
  void saveFrameRect {
    frameRect(grabFrameRect());
  }
  
  void restoreFrameRect {
    if (frameRect != null)  
      setBounds(window, frameRect);
  }
  
  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;
    restoreFrameRect();
    //onWindowClosing(window, -> host.cleanExit());
    onBoundsChange(window, r saveFrameRect);
    
    if (host.restrictWindowsToScreenSize)
      restrictWindowToScreenSize(window);
    
    alwaysOnTop(window, alwaysOnTop);
  }
  
  void activateWindow {
    print("activateWindow: " + window);
    if (window != null)
      activateFrame_v3(window);
    else
      startAndShow(false);
  }
  
  bool isMain() { ret this == db.mainStem; }
  
  void minimize {
    cset(this, minimized := true);
    if (!minimizeToTray || host.trayIcon == null || !isMain())
      minimizeWindow(window);
    else
      hideWindow(window);
  }
  
  void deleteMe {
    temp tempPrintAlsoToSystemOut();
    print("deleteMe " + isMain());
    if (isMain())
      host.closeDatabase(db);
    else
      delete();
  }
  
  close {
    disposeWindow(window);
    cleanUp(module);
  }
  
  void delete :: before {
    close();
  }
  
  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)));
    icons.add(toolTip("Close this window", jimageButtonScaledToWidth(16, #1103067, rThread deleteMe)));
      
    //setHorizontalMarginForAllButtons(icons, 4);
    icons.add(new JPopDownButton(menu -> fillJPopupMenu(menu, flattenToList(
              
      // always on top
      
      jCheckBoxMenuItem/*_dyn*/("Always on top",
        /*->*/ alwaysOnTop,
        alwaysOnTop -> setAlwaysOnTop(alwaysOnTop)),
        
      // quit, restart + update
      
      "---",
      "Exit Gazelle", rThread { host.cleanExit() },
      "Restart", rThread { host.restart() },
      "Re-open project", rThread { host.reopenDB(db) },
      "Hide project", rThread { db.hide() },
      "Update Gazelle", rThread { host.upgradeGazelle() },
      !isMain() ? null : jCheckBoxMenuItem/*_dyn*/("Auto-Update",
        /*->*/ print(autoUpdate := db.g22utils.autoUpdateEnabled()),
        b -> {
          // save flag
          db.g22utils.setAutoUpdate(b);
          
          // if user just turned on auto-update, do the update
          if (b) thread { host.upgradeGazelle(); }
        }),

      // debugging + screenshooting gazelle
      
      "---",
      !isMain() ? null : ll(
        "Screenshoot this window", rThread shootWindow,
        "Dump threads", rThread { showText("User threads", renderUserThreadsWithStackTraces()); },
        "Log", !isMain() ? null : r { db.showPrintLog() },
        "Copy log to clipboard", !isMain() ? null : rThread {
          copyToClipboard(printLog());
          infoBox("Copied log to clipboard");
        },
        "10 Second Profiler", rThread runTenSecondProfiler,
      ),
      
      ccallOpt(module, "popDownItems")
    ))));
    
    JComponent actualTitle = titleComponent = fontSizePlus(7, jCenteredLabel(title));
    installWindowDragger(actualTitle);
    
    if (/*isMain() &&*/ host.devMode())
      actualTitle = centerAndEastWithMargin(actualTitle,
        jline(
          compileButton = makeCompileButton(),
          installWindowDragger(lblComputerAndUserCount()),
        ));
        
    updateFrameIcon();
    
    var spacer = gazelle_wavySpacer(color1(), color2());
    var titleBarMain = setOpaqueBackground(color1(),
      jtransparent_recursive(westCenterAndEastWithMargin(
        scpFrameIcon(),
        actualTitle,
        setOpaqueBackground(color2(), spacer)));
    
    installWindowDragger(spacer);
    
    var titleBar = setBackground(color2(), centerAndEast(
      titleBarMain,
      icons));
    
    var border =
      // createBevelBorder();
      BorderFactory.createLineBorder(color1(), host.borderSize);
      
    var outerPanel = withBorder(border,
      northAndCenter(titleBar, contents));
      
    installWindowResizeDraggerOnBorder(outerPanel);
    ret markVisualizer(this, outerPanel);
  }
  
  swappable S frameIconID() { ret host.trayIconImageID; }
  swappable int frameIconHeight() { ret 24; }
  
  selfType frameIconID(S iconID) {
    frameIconID = -> iconID;
    updateFrameIcon();
    this;
  }
  
  swappable JComponent makeFrameIcon() {
    ret jImage_scaledToHeight(frameIconHeight(), frameIconID());
  }
  
  void updateFrameIcon {
    scpFrameIcon().set(makeFrameIcon());
  }
  
  swappable Color color1() { ret host.color1; }
  swappable Color color2() { ret host.color2; }

  JLabel lblComputerAndUserCount() {
    JLabel label = jlabel();
    Runnable update = -> {
      Int computerCount = host.computerCount();
      Int userCount = host.lvGazelleUserCount()!;
      setText(label, 
        (computerCount == null ? "" : n2(computerCount))
        + appendSquareBracketed(
          userCount == null ? "" : n2(userCount)));
    };
    bindChangeListenerToComponent(label, host.lvComputerCount(), update);
    bindChangeListenerToComponent(label, host.lvGazelleUserCount(), update);
    ret label;
  }
  
  JButton makeCompileButton() {
    var gears = resizeImageIcon(imageIcon(#1103061), 16);

    var btn = jimageButtonScaledToWidth(16, #1101268, "Compile & update",
      rThread { host.compile() });
    //enableComponentAccordingToVar(host.compileButtonEnabled, btn);
    
    componentPopupMenuItems(btn,
      "Compile all", rThread { host.compileAll() },
      "Compile main library", rThread { host.compileUtilsAndRepackage() },
      "Repackage", rThread { host.repackage() },
    );
    
    ret btn;
  }
  
  JComponent wrapVis(JComponent vis) {
    //ret jMinSize0(vis);
    ret vis;
  }
  
  void startAndShow(bool hidden default false) {
    if (module._host != this) {
      module._host = this;
      setOpt_raw(module, +threadPool); // only if the field exists
      setOpt_raw(module, concepts := db.concepts);
      setOpt_raw(module, g22utils := db.g22utils);
      copyLocalLog(module, mc());
    }
  
    var vis, title = unpair startAndVisualize();
    
    if (!hidden) {
      printWithMS("Show frame");
  
      JFrame frame = makeUndecoratedFrame(title, wrapVis(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> startAndVisualize() {
    JComponent vis = null;
    {
      printWithMS("Starting " + module);
      try {
        if (!started) {
          set started;
          temp module.enter();
          module.start();
        }
      
        printWithMS("Visualize");
        vis = swing(-> {
          temp module.enter();
          ret module.visualize();
        });
      } on fail e {
        waitForFrameClose(showErrorFrame(e));
      }
    }
    
    selfVis = vis;
    
    var scp1 = scpMainWindowContents();
    scp1.set(vis);
    
    S title = createTitleText();
    var vis2 = makeWindowBorderAndTitle(scp1, title);
    
    var scp2 = scpMainWindowWithTitle();
    scp2.set(vis2);
    ret pair(scp2, title);
  }
    
  S createTitleText() {
    S moduleName = takeFirst_unnull(800, module.moduleName());
    
    if (isMain())
      // OLD: ret host.windowTitle + appendWithColon(moduleName);
      ret joinNemptiesWithVBar(moduleName, host.windowTitle);
    else
      ret moduleName;
  }
  
  void revisualize {
    if (window == null) ret;
    
    pcall {
      module.unvisualize();
    }
    
    var vis, title = unpair startAndVisualize();
    setFrameContents(window, wrapVis(vis));
  }
  
  void shootWindow {
    var img = renderComponentToImage(window);
    copyImageToClipboard(img);
    File imgFile = saveInImageDirectoryWithCounter(gazelle22_imagesSubDirName() + "/Gazelle", img);
    pcallOpt(module, "addToGallery", imgFile);
  }
  
  // Breaking change 2022 Dec 10 (is this even used?)
  // old: Component vis() { ret getFrameContents(window); }
  Component vis() { ret scpMainWindowContents()!; }
  
  S tenSecondProfilerScript = [[
    temp profiler <- new AllThreadsProfiler
    infoBox "Profiling..."
    profiler start
    sleepSeconds 10
    showText "10 Second Profile" < profiler renderFullResults false
  ]];
  
  File byteCodePath() {
    ret assertNotNull(getBytecodePathForClass(this));
  }
  
  ClassNameResolver classNameResolver() {
    ret new ClassNameResolver().byteCodePath(byteCodePath()).init();
  }
  
  GazelleV_LeftArrowScriptParser leftArrowParser() {
    new GazelleV_LeftArrowScriptParser parser;
    parser.classNameResolver(classNameResolver());
    parser.allowTheWorld(mc(), utils.class);
    ret parser;
  }
  
  void runTenSecondProfiler {
    leftArrow(leftArrowParser(), tenSecondProfilerScript);
  }
} // end of Stem

sclass LoadedDB is AutoCloseable, IG22LoadedDB {
  GazelleHost host;
  gettable Concepts concepts;
  gettable new G22Utils g22utils;
  Stem mainStem;
  gettable bool hidden;
  
  *(GazelleHost *host, Concepts *concepts, bool *hidden) {
    g22utils.concepts(concepts);
    g22utils.masterStuff(host);
  }
  
  S name() {
    ret fileName(conceptsDir(concepts));
  }
  
  void start {
    concepts.grabThroughSocket(false);
    concepts.makeStructureData = -> {
      structure_Data data = concepts.makeStructureData_base();
      data.realShortName = name -> {
        S n = dropPrefixOrNull("userCode.", name);
        if (n != null)
          ret takeFirst(n, indexOf(n, '_'));
        ret data.realShortName_base(name);
      };
      data.mcDollar = mcDollar();
      ret data;
    };
    var lock = concepts.fileLock();
    try {
      lock.contentsForLockFile("Locked by computer " + computerID() + "\n");
      lock.lockOrFail();
    } catch print e {
      if (cic(str(e), "Couldn't aquire lock")) {
        if (!lock.hasExpectedContents()) {
          infoBox("Overriding project lock (" + lock.actualContents() + ")");
          lock.forceLock();
        } else {
          S msg = "This project is already opened in another process";
          infoBox(msg, 10.0);
          sleepSeconds(1);
          fail(msg);
        }
      } else
        throw rethrow(e);
    }
    concepts.fileLock().deleteOnExit();
    thinAProgramsBackups(concepts.conceptsDir(), true);
    
    //concepts.persist();
    concepts.loadConcepts();
    
    // Check that we are not loading with an old program version
    var projectInfo = optimizedUniq(concepts, G22ProjectInfo);
    S compilationDate = compilationDateFromClassPath(this);
    print("Compilation date in project: " + projectInfo.compilationDate);
    
    if (nempty(projectInfo.compilationDate)
      && lessThan(compilationDate, projectInfo.compilationDate)) {
        messageBoxAndFail("Trying to open project with old Gazelle version - please update Gazelle first (" + compilationDate + " vs " + projectInfo.compilationDate + ")");
        }
        
    if (cset(projectInfo, +compilationDate) != 0)
      print("Bumped compilation date in project to " + compilationDate);

    concepts.autoSaveConcepts();
    
    //db_setMainConcepts(concepts);
    
    //print("Concepts loaded: " + map className(allConcepts(concepts));
    
    var stems = stems();
    print("Stems in DB: " + l(stems));
    mainStem = first(stems);
    if (mainStem == null) {
      print("Starting new module");
      var module = host.makeModule();
      mainStem = registerConcept(concepts, new Stem(this, module));
      print("Stems in DB: " + l(stems()));
    }

    for (stem : stems()) {
      stem.db = this;
      stem.host = host;
      stem.startAndShow(hidden);
    }
    
    print("Stems in DB: " + l(stems()));
  }
  
  L<Stem> stems() { ret list Stem(concepts); }
  
  Q systemQ() { ret host.systemQ; }

  Stem findPrintLog() {  
    ret firstThat(list(concepts, Stem),
      stem -> stem.module instanceof PrintLogModule);
  }
  
  void showPrintLog {
    systemQ().add(-> {
      var logModule = findPrintLog();
      if (logModule != null)
        logModule.activateWindow();
      else
        registerConcept(concepts, new Stem(this, new PrintLogModule)).startAndShow();
    });
  }
  
  void hidePrintLog {
    systemQ().add(-> deleteConcept(findPrintLog()));
  }
  
  void activate {
    print("Activating DB: " + conceptsFile(concepts));
    if (hidden) {
      hidden = false;
      host.loadedDBsChange();
    }
    mainStem?.activateWindow();
  }
  
  void hide {
    hideWindow(mainWindow());
    if (!hidden) {
      hidden = true;
      host.loadedDBsChange();
    }
  }
  
  public JFrame mainWindow() {
    ret mainStem?.window;
  }

  close {  
    print("Cleaning up " + concepts);
    print("Stems in DB: " + l(stems()));
    
    for (Concept c : allConcepts(concepts))
      cleanUp(c);
      
    print("Releasing DB (" + n2(list(concepts, Stem), "stem") + ")");
    dispose concepts;

    host.loadedDBs.remove(this);
    host.loadedDBsChange();
    
    print("Remaining DBs: " + l(host.loadedDBs));
  }
  
  toString { ret name(); }
  
  DynModule module() {
    ret mainStem?.module;
  }
  
  public G22ProjectActions projectActions() {
    ret (G22ProjectActions) module();
  }
} // end of LoadedDB

// This replaces the Stefan's OS main class. It is not persisted
// and there is only one instance.

transient sclass GazelleHost is G22MasterStuff {
  Set<LoadedDB> loadedDBs = syncLinkedHashSet();
  event loadedDBsChange;
  event newClassesDefined;
  
  transient S repackageURL = "https://botcompany.de/jar/1033860?withX30=1&withLibs=1&noSrc=1&mainClassForManifest=Starter&repackage=1";

  // Title of this Gazelle instance
  transient S windowTitle = "Gazelle 22";
  
  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 File dbMotherDir;
  
  transient TrayIcon trayIcon;
  transient TrayIconLastPosition trayIconLastPosition;
  
  transient S[] args;
  transient Set<S> argsSet;
  transient bool incrementalDownloads = true;
  transient volatile bool shuttingDown;
  
  transient bool restrictWindowsToScreenSize /*= true*/;
  
  // This caused problems, disabled for now
  transient bool allowFrameMaximization;
  
  transient G22Utils g22utils;
  transient StefansOS_ConnectToServer serverConnector;
  transient ComputerCountListener computerCount;
  transient GazellePresenceListener gazellePresenceListener;
  
  transient gettable Q systemQ = startQ("System Q");
  
  transient AutoCloseable pimpedPopups;
  
  // Let's use one of these centrally because it blocks a thread
  // and does next to nothing most of the time.
  gettable new RunnablesReferenceQueue runnablesReferenceQueue;
  
  transient gettable ILASClassLoader lasClassLoader =
    //new LASClassLoader(getClass());
    new LASMultiClassLoader(mc()).runnablesReferenceQueue(assertNotNull(runnablesReferenceQueue));
  
  //transient BoolVarWithNotify compileButtonEnabled = new(true);
  
  gettable EphemeralObjectIDs ephemeralObjectIDs = new()
    .runnablesReferenceQueue(assertNotNull(runnablesReferenceQueue));
    
  transient bool autoExitDisabled;
  
  event fillingTrayIconMenu(PopupMenu menu);
  
  // add fields here
  
  *(ThreadPool *threadPool, IF0<DynModule> *moduleMaker) {
    g22utils = new G22Utils().masterStuff(this);
    
    onLoadedDBsChange(-> {
      if (shuttingDown) ret;
      var dbs = getLoadedDBs();
      if (nempty(dbs))
        g22utils.setOpenDBs(dbs);
      updateTrayIconMenu();
    });
  }
  
  // Reminder: We are in GazelleHost
  
  <A> A inSystemQ(IF0<A> f) {
    ret evalInQ(systemQ(), f);
  }
  
  JFrame mainWindow() {
    ret firstNonNull(loadedDBs(), db -> db.mainWindow());
  }

  void trayIconLeftClick {
    first(loadedDBs()).activate();
  }
  
  void makeTrayIcon {
    pcall-short {
      trayIcon_imageAutoSize = false;
      trayIcon = installTrayIcon(trayIconImageID, windowTitle,
        r trayIconLeftClick,
        /*"Show " + windowTitle, r trayIconLeftClick,
        "Exit " + windowTitle, r cleanExit*/
      );
      
      updateTrayIconMenu();
      trayIconLastPosition = new TrayIconLastPosition(trayIcon);
    }
  }
  
  void updateTrayIconMenu { rstUpdateTrayIconMenu.trigger(); }
  
  transient ReliableSingleThread rstUpdateTrayIconMenu = rstWithPostDelay(1000, l0 updateTrayIconMenuImpl);
  
  void updateTrayIconMenuImpl {
    if (trayIcon == null) ret;
    
    new PopupMenu menu;
    var projects = openProjects();
    printVars("updateTrayIconMenuImpl", +projects);
    for (IG22LoadedDB otherDB : projects) {
      S name = otherDB.g22utils().projectName();
      S status = otherDB.hidden() ? "Hidden" : "";
      addMenuItem(menu, name + appendSquareBracketed(status), rThread { otherDB.activate() });
    }
    
    fillingTrayIconMenu(menu);

    addMenuItem(menu, "Exit " + windowTitle, rThread cleanExit);
    trayIcon.setPopupMenu(menu);
  }
  
  void run(S[] args) {
    try {
      this.args = args;
      run2(args);
    } catch print e {
      //messageBox(e);
      hideTrayIcon(trayIcon);
      onWindowClosing(-> systemExit(1), getWindow(
        showText_fast_noWrap("Gazelle Error", renderStackTrace(e))));
    }
  }
  
  void run2(S[] args) {
    argsSet = asSet(args);
    
    S s = first(args);
    bool isDirectory = isDirectory(s);
    if (isDirectory)
      dbMotherDir = canonicalFile(s);
    printVars(args := asList(args), +s, +isDirectory, +dbMotherDir);
      
    print("Using mother directory: " + databasesMotherDir());
    
    windowTitle = or2(loadTextFile(newFile(dbMotherDir, "Gazelle Name")), windowTitle);
    
    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();
    
    //tempAddGlobalCtrlKeyListener(b -> print("Ctrl key: " + b));
    
    if (contains(argsSet, "profile"))
      doEvery(1.0, r printRunningThreads);
    
    if (containsOneOf(argsSet, "upgrade", "update"))
      ret with upgradeGazelle();
      
    makeTrayIcon();
    
    initAutoUpdate();
    
    if (devMode()) {
      print("Pimping popup menus");
      PopupMenuMaker.fix();
      pimpedPopups = tempGlobalPopupMenu((c, menu) -> {
        printVars("pimpedPopups", c := className(c));
        
        // Skip linux tray icon popups
        if (contains(className(c), "XTrayIcon")) ret;
        
        // This is for popup menus displayed via setComponentPopupMenu
        // which are re-used instances
        if (any(getMenuItems(menu), menuItem
          -> cicOneOf(menuItem.getText(), "Component: ", "src: "))) ret;
          
        O src = componentMetaSrc(c);
        menu.add(commaCombine(
          classNameAndEphString(c),
          src == null ?: "src: " + classNameAndEphString(src)));
      });
    }
    
    // Start DB
    
    LS dbNames = g22utils.dbsToOpen();
    for (S dbName : dbNames) {
      S name2 = dropPrefix("*", dbName);
      openDB(name2, !eq(dbName, name2));
    }
    
    exitIfAllDBsClosed();
    
    printWithMS("Dudadoneski");
  }
  
  public bool projectExists(S dbName) {
    File conceptsFile = newFile(newFile(databasesMotherDir(), dbName), conceptsFileName());
    ret isFile(conceptsFile);
  }
  
  LoadedDB openDB(S dbName, bool hidden default false) {
    File conceptsFile = newFile(newFile(databasesMotherDir(), dbName), conceptsFileName());
    ret openDB(conceptsFile, hidden);
  }
  
  public IG22LoadedDB getLoadedDB(Concepts concepts) {
    ret firstThat(cloneList(loadedDBs), db -> db.concepts == concepts);
  }
  
  IG22LoadedDB getLoadedDBForConceptDir(File dir) {
    ret findLoadedDBForConceptsDir(dir);
  }

  LoadedDB findLoadedDBForConceptsDir(File conceptsDir) {
    ret firstThat(cloneList(loadedDBs), db -> sameFile(
      conceptsDir(db.concepts), conceptsDir));
  }
  
  LoadedDB findLoadedDBForConceptsFile(File conceptsFile) {
    ret firstThat(cloneList(loadedDBs), db -> sameFile(
      conceptsFile(db.concepts), conceptsFile));
  }
  
  public IG22LoadedDB reopenDB(IG22LoadedDB db) {
    ret reopenDB((LoadedDB) db);
  }
  
  LoadedDB reopenDB(LoadedDB db) {
    File conceptsFile = db.concepts.conceptsFile();
    try {
      autoExitDisabled = true;
      closeDatabase(db);
      ret openDB(conceptsFile);
    } finally {
      autoExitDisabled = false;
    }
  }
  
  LoadedDB openDB(File conceptsFile, bool hidden default false) {
    ret inSystemQ(-> {
      var loadedDB = findLoadedDBForConceptsFile(conceptsFile);
      if (loadedDB != null) {
        if (!hidden)
          loadedDB.activate();
        ret loadedDB;
      }
        
      temp tempInfoBoxNoHide("Opening Gazelle project " + quote(fileName(dirOfFile(conceptsFile))));
      
      // profile project opening
      //temp tempProfileSingleThreadToConsole();
  
      print("Loading new DB: " + f2s(conceptsFile));
      g22utils.addToRecentDBNames(parentName(conceptsFile), hidden);
      Concepts concepts = newConceptsWithClassFinder(conceptsFile, makeClassFinder());
      
      concepts.onSaveError(l1 infoBox);
      
      // to clean-up resources in project variables
      concepts.closeConceptsOnExit(true);
      
      var db = new LoadedDB(this, concepts, hidden);
      loadedDBs.add(db);
      try {
        db.start();
        loadedDBsChange();
      } catch print e {
        loadedDBs.remove(db);
        _close(db);
      }
      ret db;
    });
  }
  
  public Cl<File> openConceptDirs() {
    ret cloneMap(loadedDBs, _db -> conceptsDir(_db.concepts));
  }
  
  O resolveModule(O moduleOrStem) {
    ret moduleOrStem cast Stem ? moduleOrStem.module : moduleOrStem;
  }
  
  void cleanExit {
    set shuttingDown;
    print("Closing " + n2(loadedDBs, "database"));
    closeAndClear(loadedDBs);
    System.exit(0);
  }
  
  File myJar() { ret getBytecodePathForClass(this); }
  
  AutoCloseable tempDisableCompileButtons() {
    ret tempDisableButtons(compileButtons());
  }

  swappable void upgradeGazelleForeplay { 
    infoBox("Updating Gazelle in 10...");
    sleepSeconds(10);
    upgradeGazelle();
  }
  
  void upgradeGazelle {
    try {
      temp tempPrintAlsoToSystemOut();
      
      // 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)) {
          int toUpdate = countFilesInZip(f)-1;
          //progress.setText("Keeping " + nFiles(toKeep));
          progress.setText("Updating " + nFiles(toUpdate));
        
          // Do we have anything to updatE?
          
          int have = countFilesInZip(myJar);
          if (l(toKeep) == have && countFilesInZip(f) == 1) {
            infoBox("Nothing to update - Gazelle is up to date!");
            deleteFile(myJarNew);
            deleteFile(myJarSaved);
            ret;
          }
          
          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()) {
    temp tempPrintAlsoToSystemOut();
    
    S javaCmd = or2(currentProcessCommand(), "java");
    S cmd = platformQuoteArgs(flattenToList(
      javaCmd, "-jar", jar, args));
    print(cmd);
    nohup(cmd);
    cleanExit();
  }
  
  DynModule makeModule() {
    ret 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 (g22utils.autoUpdateEnabled() /*&& autoUpdateDisabled*/) {
            upgradeGazelleForeplay();
          }
          //infoBox("Gazelle can be updated!");
        }
      } else if (swic(uri, "/edit/", m)) {
        S snippetID = fsI(firstIntAsString(m.rest());
        if (contains(stdFunctionListSnippetIDs(), snippetID))
          stdFunctions_clearCache();
        if (contains(standardClassesSnippetIDs(), snippetID))
          standardClassesMap_clearCache();
      }
    });
    
    pcall {
      computerCount = new ComputerCountListener(serverConnector);
      computerCount.init();
    }
    
    pcall {
      gazellePresenceListener = GazellePresenceListener(serverConnector);
      gazellePresenceListener.init();
    }
  }
  
  S downloadURL() {
    ret "https://botcompany.de/jar/" 
      + psI(programID()) + "?withLibs=1&withX30=1"
      + "&mainClassForManifest=Starter"
      + (!downloadJarWithSrc() ? "&noSrc=1" : "")
      + (downloadUncompressedJAR() ? "&uncompressed=1" : "");
  }
  
  bool downloadJarWithSrc() { true; }
  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(); }
  
  public IGetterWithNotify<Int> lvGazelleUserCount() { ret gazellePresenceListener?.userCount; }
  
  L<JButton> compileButtons() { ret mapNonNulls(allStems(), s -> s.compileButton()); }
  
  L<Stem> allStems() {
    ret concatLists(cloneMap(loadedDBs, db -> list(db.concepts, Stem)));
  }
  
  // compile main program
  void compile {
    compile(programID, null);
  }
  
  void resetNeedLatest {
    editSnippet(#1035306, "need latest .");
  }
  
  void compileAll {
    resetNeedLatest();
    compile(utilsSnippetID(), l0 compile);
  }
  
  void compileUtilsAndRepackage {
    compile(utilsSnippetID(), l0 repackage);
  }
  
  void compile(S snippetID, Runnable onSuccess) {
    print("Compiling " + snippetID);
    
    var gears = resizeImageIcon(imageIcon(#1103061), 16);
    
    temp tempDisableCompileButtons();
    temp tempSetButtonImages(compileButtons(), gears);
    
    thread { existingFilesInfo(); } // precompute
          
    var tr = TranspileWithErrorWindow().snippetID(snippetID);
    /*tr.transpileAction(->
      new TranspileForServer_v2(snippetID).run());*/
    tr.transpileAction(-> {
      var p = transpileOnNewServer(snippetID, "medium");
      if (!p.a) fail(p.b);
    });
    tr.onSuccess(onSuccess);
    tr.run();

    print("Done transpilation of " + snippetID);
  }
  
  void repackage {
    File f = javaxCachesDir("Gazelle-22/repackaged.jar");
    deleteFile(f);
    loadBinaryPageToFile(appendParamsToURL(repackageURL, uniq := randomID()), f);
    if (isJAR(f))
      infoBox("Repackaged.");
    else
      messageBox("Oh shit");
  }
  
  public void closeDatabase(LoadedDB db) {
    db.close();
    exitIfAllDBsClosed();
  }
  
  void exitIfAllDBsClosed {
    if (!autoExitDisabled && empty(loadedDBs))
      cleanExit();
  }
  
  Cl<? extends IG22LoadedDB> getLoadedDBs aka loadedDBs() {
    ret cloneList(loadedDBs);
  }
  
  public void closeDatabase(File conceptsDir) {
    for (db : cloneList(loadedDBs))
      if (sameFile(conceptsDir, conceptsDir(db.concepts)))
        db.close();
  }
  
  public void switchToDatabase(File conceptsDir) {
    if (conceptsDir == null) ret;
    // open/activate the desired database first
    var db = openDatabase(conceptsDir);
    
    if (db == null) ret; // probably impossible but whatever
    
    closeAllDBsExcept(db);
  }
  
  void closeAllDBsExcept(LoadedDB db) {
    closeAll(listMinus(loadedDBs, db));
  }
  
  public LoadedDB openDatabase(File conceptsDir, bool hidden default false) {
    temp tempPrintAlsoToSystemOut();
    
    File conceptsFile = newFile(conceptsDir, conceptsFileName());
    if (!fileExists(conceptsFile))
      fail(infoBox("Database not found: " + conceptsFile));
      
    var db = openDB(conceptsFile, hidden);
    
    print("Database opening complete");
    ret db;
  }
  
  Map<S, Class> classMigrations() {
    ret litmap(
      G22RecognizerScript := G22Analyzer,
      GalleryImage := G22GalleryImage);
  }

  public IF1<S, Class> makeClassFinder() {
    IF1<S, Class> defaultClassFinder = toIF1(_defaultClassFinder());
    var migrations = classMigrations();
    IF1<S, Class> classFinder = name -> {
      // class migration
      S shortName = dropPrefixOrNull("main$", name);
      if (shortName != null) {
        Class c = migrations.get(shortName);
        if (c != null) {
          S newName = className(c);
          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;
  }
  
  bool devMode() { ret g22_devMode(); }
  
  // remember ephemeral object, return script code to get it back
  S ephString(O o) {
    ret o == null ? "" : "eph " + ephemeralObjectIDs.remember(o);
  }
  
  S classNameAndEphString(O o) {
    ret o == null ?: spaceCombine(ephString(o), className(o));
  }
  
  public File databasesMotherDir() {
    if (dbMotherDir == null)
      dbMotherDir = javaxDataDir("Gazelle-22");
    ret dbMotherDir;
  }
} // end of GazelleHost [G22MasterStuff]