srecord noeq G22ChallengePanel(G22Challenge challenge) extends HasChangeListeners is Swingable {
  settableWithChange long randomSeed = 1; //randomUnsignedInt();
  
  //transient JPanel imagesPanel = jline();
  transient DynamicHStack imagesPanel;
  transient L<Entry> entries = syncL();
  transient JComponent imagesSection;
  transient GazelleV_LeftArrowScript.Script parsedScript;
  settableWithChange Set<Class> solutionTypes = syncSet();
  transient JButton btnShowSolutions;
  transient G22LAScriptIDE<G22RecognizerScript> recognizerIDE;

  transient settable G22Utils g22utils;
  settable bool autoRunChallenge;
  settable double timeoutToMakeAnImage = 10.0;
  settable double timeoutToRecognizeAnImage = 10.0;
  settable int imagesToPaint = 3;
  settable int interval = 100;
  settable int imageDisplaySize = 100;
  settable Color imageBorderColor1 = Color.green;
  settable Color imageBorderColor2 = Color.red;
  settable int imageBorderSize = 1;
  
  void init {
    recognizerIDE = new G22LAScriptIDE(g22utils);
    //recognizerIDE.sectionTitle("Recognizer " + roundBracket(recognizerIDE.sectionTitle));

    recognizerIDE.modifyIDE = ide -> {
      ide.runScript = -> {
        var compileResult = ide.freshCompileResult();
        var script = compileResult.parsedScript;
        if (script == null) ret;
        
        var bg = g22utils.backgroundProcessesUI();
        temp bg?.tempAdd("Run recognizer on " + challenge);
        
        new FlexibleVarContext ctx;
        
        try {
          L<OKOrError> results = syncL();
          long time = sysNow();
          for (Entry entry : filter(entries, e -> e.image != null)) {
            ctx.put(image := entry.image);
            var result = okOrError(->
              ide.callCompiledObjectWithTimeout(
                timeoutToRecognizeAnImage,
                script, ctx));
            results.add(result);
            entry.computerResult(result);
          }
          time = sysNow()-time;
          ide.showScriptResult(OKOrError.ok("Got " + nResults(results) + " in " + formatSeconds(time, 3) + " s"));
        } catch print e {
          ide.showScriptResult(OKOrError.error(e));
        }
      };
    };
  }
  
  visualize {
    if (recognizerIDE == null) init();
    
    imagesPanel = (DynamicHStack) dynamicHStack().spacing(20);
    awtCalcEvery(imagesPanel, interval, r _paintAnImage);
    
    ret withCenteredBoldTitle("Challenge: " + challenge,
      withTopMargin(jvsplit(
        northCenterAndSouthWithMargin(
          centerAndEastWithMargin(
            centeredLiveValueLabel(
              liveValue_hasChangeListeners(this,
                -> "Looking for: " + solutionTypeDesc())),
            swing(-> JPopDownButton(menu ->
              menu.add(jMenuItem("Random seed " + n2(randomSeed)))))
          ),
          imagesSection = jCenteredRaisedSection("Images", jBorderlessHigherScrollPane(jfullcenter(imagesPanel))),
          withBottomMargin(jCenteredLine(btnShowSolutions = jbutton("Show solutions", l0 showSolutions)))
          /*jRightAlignedLine(
            withLabel("Random seed:",
              liveValueLabel(liveValue_hasChangeListeners(this, -> randomSeed)))),*/
        ),
        recognizerIDE.visualize()
      )));
  }
  
  void _paintAnImage {
    if (!autoRunChallenge) ret;
    if (l(entries) >= imagesToPaint) ret;
    
    int index = l(entries)+1;
    Entry entry = new(index, (int) (randomSeed+index-1));
    entries.add(entry);
      
    try {
      if (parsedScript == null) {
        var parser = g22utils.leftArrowParser();
        var cleared = challenge.clearedForAutoRun();
        parsedScript = parser.parse(cleared?!);
      }
      
      new FlexibleVarContext ctx;
      var returnedObject = evalWithTimeoutOrTypedException(timeoutToMakeAnImage, -> {
        temp tempSetRandomSeed((int) entry.seed);
        ret parsedScript.get(ctx);
      });
      
      // can return image or put in variables "image" or "img"
      
      if (returnedObject == null)
        returnedObject = ctx.get("image");
      if (returnedObject == null)
        returnedObject = ctx.get("img");
      
      // convert to BufferedImage
        
      if (returnedObject instanceof MakesBufferedImage
        || returnedObject instanceof Image)
        returnedObject = toBufferedImage(returnedObject);
        
      if (returnedObject cast BufferedImage) {
        entry.solution(ctx.get("solution"));
        updateSolutionType(entry.solution);
        addImage(entry, returnedObject);
      } else if (returnedObject == null)
        addImage(entry, null, jcenteredlabel("No image");
      else
        addImage(entry, null, jcenteredlabel("Not an image: " + shortClassName(returnedObject)));
    } catch print e {
      entry.error(e);
      addImage(entry, null, jSmallErrorView(e));
    } finally {
      entry.calculating(false);
    }
  }
  
  void addImage(Entry entry, BufferedImage image, JComponent component) {
    entry.image(image).component(component);
    addAndRevalidate(imagesPanel, component);
    setSectionTitle(imagesSection, firstToUpper(nImages(entries)) + " calculated");
  }
  
  void addImage(Entry entry, BufferedImage image) {
    entry.image(image);
    addImage(entry, image, new EntryComponent(entry).visualize());
  }
  
  record noeq EntryComponent(Entry entry) is Swingable {
    // !customConstructor
    *(Entry *entry) { entry.entryComponent(this); }
    
    SingleComponentPanel scpSolution = singleComponentPanel();
    SingleComponentPanel scpComputerResult = singleComponentPanel();
    SingleComponentPanel scpCheckmark = singleComponentPanel();
    
    visualize {
      var image = entry.image;
      double scale = calcFitScale(image, imageDisplaySize);
      var image2 = scaleImageWithOp(image, scale,
        AffineTransformOp.TYPE_NEAREST_NEIGHBOR);
      for (color : ll(imageBorderColor1, imageBorderColor2))
        image2 = addBorderToImage(image2, color, imageBorderSize);
      S toolTip = "Image " + n2(entry.index) + " of " + challenge + " (seed " + n2(entry.seed) + ", " + image.getWidth() + "*" + image.getHeight() + " px)";
      JButton b = withToolTip(toolTip, jimageButton(image2));
      setMargin(10, b);
      ret centerAndSouthWithMargin(b,
        vstackWithSpacing(scpCheckmark, scpSolution, scpComputerResult));
    }
    
    JComponent answerToComponent(O answer) {
      JComponent c;
      try {
        c = jCenteredLabel(shorten(g22utils.stringify(answer)));
      } catch e {
        c = jSmallErrorView(e);
      }
      ret jMaxWidth(imageDisplaySize+20, c);
    }
    
    void showSolution {
      scpSolution.set(withCenteredTitle("Solution", answerToComponent(entry.solution)));
    }
    
    void computerResult(OKOrError result) {
      scpComputerResult.set(withCenteredTitle("Computer Result",
        result.isOK()
          ? answerToComponent(result)
          : jSmallErrorView(result.error())));
          
      scpCheckmark.set(entry.computerIsCorrect() ? jImage_scaledToHeight(32, checkmarkIconID(), "Computer is correct!!") : null);
    }
  }
  
  class Entry {
    int index; // index in sequence starting with 1
    long seed; // seed for randomizer
    settable BufferedImage image;
    settable Throwable error;
    settable O solution;
    OKOrError computerResult;
    settable bool calculating = true;
    settable JComponent component;
    settable EntryComponent entryComponent;
    settable bool computerIsCorrect;
    
    *(int *index, long *seed) {}
    
    void computerResult(OKOrError result) {
      this.computerResult = result;
      computerIsCorrect(result.isOK() && eq(solution, result!));
      entryComponent?.computerResult(result);
    }
  }
  
  void updateSolutionType(O solution) {
    Class c = _getClass(solution);
    if (solutionTypes.add(c)) change();
  }
  
  S solutionTypeDesc() {
    LS types = map solutionTypeDesc(solutionTypes);
    ret textOut_or(types, "Calculating...");
  }
  
  S solutionTypeDesc(Class c) {
    if (c == null)
      ret "no solution given";
    if (c == Rect)
      ret "a rectangular area in the image";
    ret aOrAn(shortClassName(c));
  }
  
  void showSolutions {
    disableButton(btnShowSolutions);
    for (e : cloneList(entries))
      if (e.entryComponent != null)
        e.entryComponent.showSolution();
  }
}