concept CleanMoveStrategy extends G22TradingStrategy {

  // How clean the move must be

  settable double minCleanness = 2;

  // How profitable the move must be

  settable double minProfit = 0.5;

  // Factor for turning pullback into callback

  settable double callbackFactor = 1.5;

  // Max pullback of move

  settable double maxPullback = 1;

  // Price has to move at least this many percent for us to

  // recalculate the moves

  //settable double minChangeToReactTo = 0.1;

  // How often to start a new move analysis (seconds)

  settable double calcMovesEvery = 30;

  S fieldsToReset() {

    ret lines(ll(super.fieldsToReset(), [[currentMoves lastPriceReactedTo movesCalced]]));

  }

  // current short & long move

  settable L<LivePullbackToProfitAnalysis> currentMoves;

  //settable double lastPriceReactedTo;

  settable double movesCalced;

  persistable class Position extends G22TradingStrategy.Position {

    settable CallbackJuicer juicer;

  }

  srecord ProfitBeforeLeverageJuiceable(Position p) is Juiceable {

    public double juiceValue() { ret p.profitBeforeLeverage(); }

  }

  void price(double price) {

    if (currentPrice == price) ret;

    currentPrice = price;

    afterwards { afterStep(); change(); }

    // Close positions

    for (p : openPositions()) {

      if (p.juicer != null) {

        var signals = p.juicer.calculateCloseSignals();

        var strongest = highestBy(signals, s -> s.strength());

        if (strongest != null && strongest.isTrigger())

          p.close(strongest);

      }

    }

    // Check if we should start a position

    if (empty(openPositions()) && shouldCalcMoves()) {

      // Calculate 2 current moves backwards in time

      var time = currentTime();

      currentMoves = map(falseTrue(), isShort -> {

        new LivePullbackToProfitAnalysis a;

        a.pullbackLimit(maxPullback);

        a.isShort(isShort);

        int idx = actualTicker.indexOfTimestamp(currentTime());

        while (idx >= 0 && !a.done())

          a.feed(actualTicker.getPricePoint(idx--));

        ret a;

      });

      bool shouldShort = false, shouldLong = false;

      PullbackToProfit openReason = null;

      for (move : currentMoves)

        for (ptp : move.ptpList())

          if (ptp.cleanness() >= minCleanness && ptp.profit() >= minProfit) {

            openReason = ptp;

            if (openReason.isShort)

              shouldLong = true;

            else

              shouldShort = true;

          }

      if (shouldShort && shouldLong)

        print("Conflicting signal (long+short at once)");

      else if (shouldShort || shouldLong) {

        int direction = shouldShort ? -1 : 1;

        new Position p;

        p.marginToUse = marginPerPosition;

        var callbackRate = openReason.pullback*callbackFactor;

        p.juicer = new CallbackJuicer(callbackRate);

        p.juicer.juiceable(new ProfitBeforeLeverageJuiceable(p));

        openPosition(p, direction, openReason);

      }

    }

  }

  bool shouldCalcMoves() {

    /*if (!differentByEpsilonRatio(lastPriceReactedTo, currentPrice, minChangeToReactTo/100))

      false;

    lastPriceReactedTo(currentPrice);

    true;*/

    var time = currentTime();

    if (time >= movesCalced+fromSeconds(calcMovesEvery)) {

      movesCalced = time;

      true;

    }    

    false;

  }

  L<? extends Position> openPositions() { ret (L) super.openPositions(); }

  LS status() {

    ret listCombine(

      map(currentMoves, move -> "Move: " + move),

      super.status()

    );

  }

}