persistable sclass MultiCallbackJuicer extends AbstractJuicer {

  // Must have at least one level, otherwise no closing at all

  sclass Level {

    // At juice value minJuiceValue, define the callback rate.

    // Callback rates are interpolated between levels.

    settable double minJuiceValue;

    settable double callback;

    toString { ret "Callback " + callback + "% starting at " + formatDouble2(minJuiceValue); }

  }

  settableWithVar new L<Level> levels;

  // Highest juice value seen

  settableWithVar double crest = -infinity();

  settableWithVar double currentCallback;

  {

    onCalculatingCloseSignals(signals -> {

      if (juiceValue > crest)

        crest(juiceValue);

      currentCallback(callbackForJuiceValue(crest));

      var signal = new CloseSignal().createdBy(this).reason(formatDouble2(currentCallback) + "% Callback");

      signal.strength(doubleRatio(crest-juiceValue, currentCallback)*100);

      signals.add(signal);

    });

  }

  double callbackForJuiceValue(double juice) {

    for (int i = l(levels)-1; i >= 0; i--) {

      Level level = levels.get(i);

      if (juice < level.minJuiceValue)

        continue;

      Level nextLevel = get(levels, i+1);

      if (nextLevel == null)

        ret level.callback;

      ret blend(level.callback, nextLevel.callback,

        transformToZeroToOne(juice, level.minJuiceValue, nextLevel.minJuiceValue));

    }

    ret empty(levels) ? 1000 : first(levels).callback;

  }

  void addLevel(double minJuiceValue, double callback) {

    levels.add(new Level().minJuiceValue(minJuiceValue).callback(callback));

  }

  toString {

    ret commaCombine(

      shortClassName(this),

      levels,

      crest == -infinity() ? null : "Highest profit seen: " + formatDouble2(crest),

      "Current callback: " + formatDouble2(currentCallback),

    );

  }

  void copyTransientValuesFrom(AbstractJuicer juicer) {

    if (juicer cast MultiCallbackJuicer)

      crest(juicer.crest);

  }

}