persistable sclass MultiStopLossJuicer extends AbstractJuicer {

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

  sclass Level {

    // At juice value minJuiceValue, define the stopLoss.

    settable double minJuiceValue;

    settable double stopLoss;

    toString { ret "Stop loss " + stopLoss + "% starting at " + formatDouble2(minJuiceValue); }

  }

  settableWithVar new L<Level> levels;

  // Highest juice value seen

  settableWithVar double crest = -infinity();

  // for current level, set by MultiStopLossJuicer itself

  settableWithVar StopLossJuicer stopLossJuicer;

  settableWithVar int levelsTriggered;

  Level nextLevel() { ret _get(levels, levelsTriggered); }

  {

    onCalculatingCloseSignals(signals -> {

      if (juiceValue > crest)

        crest(juiceValue);

      Level level;

      while ((level = nextLevel()) != null && crest >= level.minJuiceValue) {

        levelsTriggered(levelsTriggered+1);

        var slj = new StopLossJuicer(level.stopLoss);

        slj.juiceable(juiceable());

        stopLossJuicer(slj);

      }

      if (stopLossJuicer != null)

        addAll(signals, stopLossJuicer.calculateCloseSignals());

    });

  }

  void addLevel(double minJuiceValue, double stopLoss) {

    levels.add(new Level().+minJuiceValue.+stopLoss);

  }

  toString {

    ret commaCombine(

      shortClassName(this),

      levels,

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

      "Levels triggered: " + levelsTriggered,

      "Current stop loss: " + stopLossJuicer,

    );

  }

  // Hmm. Is this correct?

  void copyTransientValuesFrom(AbstractJuicer juicer) {

    if (juicer cast MultiStopLossJuicer)

      crest(juicer.crest);

  }

}