// script that recognizes images or performs some kind of analysis on an image

concept G22Analyzer > G22LeftArrowScript {

  new Ref<G22GalleryImage> exampleImage;

  @Override GazelleV_LeftArrowScriptParser makeParser() {

    var parser = super.makeParser();

    parser.addVar("image", BufferedImage.class, false);

    parser.addVar("imageStream", SourceTriggeredStream.class, false);

    parser.addVar("context", G22AnalysisContext.class, false);

    ret parser;

  }

  class CompiledAnalyzer > LASCompileResult {

    settable double timeout = 10;

    G22AnalysisContext createAnalysisContext(BufferedImage image) {

      ret new G22AnalysisContext(g22utils(), image);

    }

    // evaluate directly without registration or timeout

    O get_impl(G22AnalysisContext context) {

      new FlexibleVarContext ctx;

      ctx.set(image := context.image);

      ctx.set(imageStream := context.imageStream);

      ctx.set(+context);

      ret parsedScript.get(ctx);

    }

    O get_impl(BufferedImage image) {

      ret get_impl(createAnalysisContext(image));

    }

    O get(BufferedImage image) {

      ret get(createAnalysisContext(image));

    }

    O get(G22AnalysisContext context) {

      if (context.analyzerResults.containsKey(analyzer())) {

        O value = context.analyzerResults.get(analyzer());

        if (value == G22AnalysisContext.calculating)

          fail("Recursive call to analyzer " + this);

        ret ((OKOrError) value).getMandatory();

      }

      context.analyzerResults.put(analyzer(), G22AnalysisContext.calculating);

      var result = okOrError(-> {

        if (parsedScript == null) rethrow(compileError);

        if (context.image == null

          && context.imageStream == null)

          fail("Need image or imageStream");

        ret g22utils().evalRegisteredCode(timeout, str(G22Analyzer.this),

          -> get_impl(context));

      });

      context.analyzerResults.put(analyzer(), result);

      ret result.getMandatory();

    }

  }

  selfType analyzer() { this; }

  LASCompileResult newCompileResult() { ret new CompiledAnalyzer; }

  CompiledAnalyzer compileForAutoRun() {

    ret (CompiledAnalyzer) super.compileForAutoRun();

  }

}