sclass JLeftArrowScriptIDE is Swingable {
  settable SimpleLiveValue<S> lvScript = stringLiveValue();
  S sectionTitle = "Left arrow script";
  
  sS helpText = !include string #1034045;
  
  transient CompileResult compileResult;
  transient RSyntaxTextAreaWithSearch taScript;
  transient new Q compileQ;
  transient JLabel lblCompileResult;
  transient JButton btnRun;
  transient SingleComponentPanel scpResult;
  
  transient LeftArrowCompletionProvider completionProvider;
  transient AutoCompletion autoComplete;
  
  settable transient new G22Utils g22utils;
  
  class LeftArrowCompletionProvider extends DefaultCompletionProvider {
    @Override
    public L<Completion> getCompletionByInputText(S inputText) {
      print("getCompletionByInputText: " + quote(inputText));
      ret ll(
        new BasicCompletion(this, inputText + "YesYes"),
        new BasicCompletion(this, inputText + "NoNo"));
    }
    
    /*@Override
    public L<Completion> getCompletions(JTextComponent comp) {
      var l = super.getCompletions(comp);
      print("getCompletions: " + l);
      ret l;
    }*/
    
    @Override
    public L<Completion> getCompletionsImpl(JTextComponent comp) {
      S text = getText(comp);
      new GazelleV_LeftArrowScriptParser parser;
      modifyParser(parser);
      LeftArrowScriptAutoCompleter completer = new(parser);
      completer.seek(text, getCaretPosition(comp));
      ret map(completer.searcher().withScores(), completion -> {
        BasicCompletion c = new(this, completion!);
        c.setRelevance((int) completion.score());
        ret c;
      });

      //ret getCompletionByInputText(getAlreadyEnteredText(comp));
    }
  }
  
  visual {
    taScript = liveValueRSyntaxTextArea_bothWays(lvScript);
    awtCalcEvery(taScript.textArea(), 1.0, -> compileQ.add(r compile));
    
    swing {
      completionProvider = new LeftArrowCompletionProvider;
      completionProvider.setAutoActivationRules(true, " ");
      autoComplete = new AutoCompletion(completionProvider);
      autoComplete.setAutoCompleteSingleChoices(false);
      autoComplete.setAutoActivationEnabled(true);
      autoComplete.setAutoActivationDelay(2000);
      autoComplete.install(taScript.textArea);
      print("Auto-complete installed on " + taScript.textArea);
    }

    JComponent vis = jCenteredSection(sectionTitle,
      centerAndSouthWithMargin(
        taScript.visualize(),
        centerAndEastWithMargin(
          lblCompileResult = jlabel(),
          jline(
            btnRun = jbutton("Run" := rThread runButtonAction),
            jPopDownButton_noText(
              "Show Scripting Help", rThread { showTextWordWrapped("Gazelle 'Left arrow script' Help", helpText) },
            )
          ))));
          
    if (scpResult != null)
      vis = jhsplit(
        jCenteredSection("Image will show here", scpResult),
        vis);
        
    ret vis;
  }
  
  bool visible() { ret isShowing(lblCompileResult); }
  
  void compile {
    var script = lvScript!;
    var result = compileResult;
    if (result == null || !eq(result.script, script)) {
      try {
        result = new CompileResult;
        result.script = script;
        result.parser = new GazelleV_LeftArrowScriptParser;
        modifyParser(result.parser);
        result.parsedScript = result.parser.parse(result.script);
        print(result.parsedScript);
      } catch print e {
        result.compileError = e;
      }
      compileResult = result;
      setText(lblCompileResult, compileResult);
      updateRunButtonState();
    }
  }
  
  void updateRunButtonState() {
    setEnabled(btnRun, runButtonShouldBeEnabled());
  }
  
  swappable bool runButtonShouldBeEnabled() {
    ret compileResult != null && compileResult.runnable();
  }
  
  CompileResult freshCompileResult() {
    runInQAndWait(compileQ, r compile);
    ret compileResult;
  }
  
  GazelleV_LeftArrowScript.Script parsedScript() {
    ret freshCompileResult().parsedScript;
  }

  swappable void runButtonAction {
    runScript();
  }
  
  void runScript {
    //showText_fast_noWrap("Script Error", renderStackTrace(e));
    var result = freshCompileResult();
    if (result.parsedScript != null) {
      result.result = okOrError(-> callCompiledObject(result.parsedScript));
      setStatus(result.result.isOK()
        ? shorten(str(result.result))
        : exceptionToStringShorter(result.result.error()));
    }
  }

  class CompileResult {
    S script;
    GazelleV_LeftArrowScriptParser parser;
    Throwable compileError;
    GazelleV_LeftArrowScript.Script parsedScript;
    OKOrError result;

    toString {
      ret compileError != null ? exceptionToStringShorter(compileError) : "Compiled OK";
    }
    
    bool runnable() { ret parsedScript != null; }
  }
  
  void setStatus(S status) {
    setText(lblCompileResult, status);
  }

  swappable void modifyParser(GazelleV_LeftArrowScriptParser parser) {
    parser.allowTheWorld(mc());
  }
  
  void showStatus(S status) {
    setText(lblCompileResult, status);
  }
  
  void showRuntimeError(Throwable e) {
    showStatus(exceptionToStringShorter(e));
  }
  
  void withResultPanel {
    scpResult if null = singleComponentPanel();
  }
  
  swappable O callCompiledObject(GazelleV_LeftArrowScript.Script object) {
    O result = object!;
    if (result cast BufferedImage)
      scpResult?.set(jscroll_centered_borderless(g22utils.stdImageSurface(result)));
    ret result;
  }
}