concept Chaser extends G22TradingStrategy {

  // Juicer parameters

  // Maximum duration of a position

  settable double maxPositionHours = 4;

  // Max loss per position before leverage

  settable double maxLoss = 0.6;

  // Ordinary pullback (fixed price percentage)

  settable double pullback = 0.4;

  // Relative pullback (percentage of profit)

  settable double relativePullback; // e.g. 20

  settable double minPullback; // e.g. 0.1

  settable double maxPullback; // e.g. 4

  settable Opener opener;

  // internal

  settableWithVar int lastDirection;

  new RunLengthCounter<Int> rlc;

  OpenSignal openSignal;

  // trigger = 0 to 1

  record noeq CloseSignal(S reason, double trigger) {

    double trigger() { ret trigger; }

    toString { ret "Close signal " + reason + " (" + iround(trigger*100) + "%)"; }

  }

  // trigger = 0 to 1

  record noeq OpenSignal(S reason, double trigger, int direction) {

    double trigger() { ret trigger; }

    toString { ret "Open signal " + reason + " (" + iround(trigger*100) + "%)"; }

  }

  persistable class BaseJuicer {

    settable double maxLoss;

    L<CloseSignal> closeSignals(Position p) {

      new L<CloseSignal> signals;

      double profit = p.profitBeforeLeverage();

      // How close are we to the max closing time?

      if (p.maxClosingTime() < infinity())

        signals.add(new CloseSignal("Age", transformToZeroToOne(currentTime(), p.openingTime(), p.maxClosingTime())));

      // How close are we to our loss limit?

      if (profit < 0)

        signals.add(new CloseSignal("Loss", doubleRatio(-profit, maxLoss));

      ret signals;

    }

  }

  // Juicer with fixed pullback

  persistable class Juicer extends BaseJuicer {

    settable double pullback;

    *(double *maxLoss, double *pullback) {}

    toString { ret renderRecord("Juicer", +maxLoss, +pullback); }

    L<CloseSignal> closeSignals(Position p) {

      L<CloseSignal> signals = super.closeSignals(p);

      double profit = p.profitBeforeLeverage();

      // How close are we to the pullback limit?

      if (profit >= 0)

        signals.add(new CloseSignal("Profit", transformToZeroToOne(profit,

          p.crest, p.crest-pullback));

      ret signals;

    }

  }

  // Juicer with relative pullback

  persistable class RelativePullbackJuicer extends BaseJuicer {

    settable double relativePullback; // e.g. 20

    settable double minPullback; // e.g. 0.1

    settable double maxPullback; // e.g. 4

    toString { ret renderRecord("RelativePullbackJuicer", +maxLoss, +relativePullback, +minPullback, +maxPullback); }

    L<CloseSignal> closeSignals(Position p) {

      L<CloseSignal> signals = super.closeSignals(p);

      double profit = p.profitBeforeLeverage();

      // How close are we to the pullback limit?

      if (profit >= 0)

        signals.add(new CloseSignal("Profit", transformToZeroToOne(profit,

          p.crest, p.crest-calculatePullback(p.crest)));

      ret signals;

    }

    double calculatePullback(double crest) {

      ret clamp(relativePullback/100*crest, minPullback, maxPullback);

    }

  }

  abstract sclass Opener {

    abstract OpenSignal openSignal();

    abstract Opener cloneInto(Chaser strat);

  }

  record PreRunOpener(int minRunUp, int minRunDown) extends Opener {

    Opener cloneInto(Chaser strat) {

      ret strat.new PreRunOpener(minRunUp, minRunDown);

    }

    OpenSignal openSignal() {

      int direction = Chaser.this.direction;

      if (direction == 0) null;

      int preRun = direction > 1 ? minRunUp : minRunDown;

      int runLength = toInt(rlc.runLength());

      /*printConcat(

        "[",

        formatLocalDateWithSeconds(currentTime()),

        "] ",

        "Runlength ",

        runLength,

        " price: ",

        formatPriceX(currentPrice())

      );*/

      // TODO: even more precise signal

      //if (runLength >= preRun) print("Pre-run signal!");

      ret new OpenSignal("RunLength " + runLength, doubleRatio(runLength, preRun), direction);

    }

    toString { ret "PreRunOpener up " + minRunUp + ", down " + minRunDown; }

  }

  persistable class Position extends G22TradingStrategy.Position {

    settable OpenSignal openSignal;

    settable BaseJuicer juicer;

    // highest profit this position has reached

    double crest = -infinity();

    double maxClosingTime() {

      ret usingLiveData ? infinity() : openingTime()+hoursToMS(maxPositionHours);

    }

    L<CloseSignal> closeSignals() {

      ret juicer == null ?: juicer.closeSignals(this);

    }

    // >= 1 to close

    // otherwise keep open

    double closeSignal() {

      CloseSignal strongestSignal = closeSignalWithDescription();

      ret strongestSignal == null ? 0 : strongestSignal.trigger;

    }

    CloseSignal closeSignalWithDescription() {

      ret highestBy(closeSignals(), signal -> signal.trigger);

    }

    void update {

      crest = max(crest, profitBeforeLeverage());

    }

    toString {

      var closeSignal = closed() ? null : closeSignalWithDescription();

      ret commaCombine(super.toString(),

        closeSignal

      );

    }

  }

  LS status() {

    ret listCombine(

      commaCombine(

        "Max loss: " + formatDouble3(maxLoss) + "%",

        relativePullback == 0

          ? "pullback: " + formatDouble3(pullback) + "%"

          : commaCombine(

            "relative pullback: " + formatDouble3(relativePullback) + "%",

            "min pullback: " + formatDouble3(minPullback) + "%",

            "max pullback: " + formatDouble3(maxPullback) + "%",

          )

      ), 

      "Opener: " + opener,

      "Run length: " + signToUpDown(unnull(rlc.value())) + " " + rlc.runLength(),

      openSignal,

      super.status()

    );

  }

  Position openPosition(OpenSignal openSignal) {

    int direction = openSignal.direction;

    if (l(positionsInDirection(direction)) > 0) {

      //log("Not opening a second position in direction " + direction);

      null;

    }

    nextStep();

    new Position p;

    p.openSignal(openSignal);

    p.juicer(makeJuicer());

    ret openPosition(p, direction);

  }

  BaseJuicer makeJuicer() {

    if (relativePullback != 0)

      ret new RelativePullbackJuicer()

        .relativePullback(relativePullback)

        .minPullback(minPullback)

        .maxPullback(maxPullback)

        .maxLoss(maxLoss);

    else

      ret new Juicer(maxLoss, pullback);

  }

  void start {

    if (started()) fail("Already started");

    if (currentPrice() == 0)

      ret with primed(true);

    // Save starting price, create price cells & digitizer

    startingPrice = currentPrice();

    var priceCells = makePriceCells(startingPrice);

    digitizer = new PriceDigitizer2(priceCells);

    digitizer.verbose(verbose);

    log("Starting CHASER at " + startingPrice + " +/- " + cellSize);

  }

  void price(double price) {

    if (currentPrice == price) ret;

    currentPrice = price;

    if (!started()) {

      if (primed) {

        primed(false);

        start();

        nextStep();

        beforeStep();

        afterStep();

      }

      ret;

    }

    digitizer.digitize(price);

    direction = sign(digitizedPrice()-lastDigitizedPrice());

    if (direction != 0) lastDirection = direction;

    if (started())

      step();

  }

  swappable void step {

    // Update positions with new price

    for (p : openPositions()) {

      cast p to Position;

      p.update();

    }

    // Find positions to close

    L<G22TradingStrategy.Position> toClose = new L;

    for (p : openPositions()) {

      cast p to Position;

      CloseSignal signal = p.closeSignalWithDescription();

      if (signal != null && signal.trigger() >= 1) {

        p.closeReason(signal);

        log("Closing position because " + signal + ": " + p);

        toClose.add(p);

      }

    }

    if (nempty(toClose)) {

      nextStep();

      closePositions(toClose);

      afterStep();

    }

    beforeStep();

    double p1 = lastDigitizedPrice();

    double p2 = digitizedPrice();

    direction = sign(p2-p1);

    if (direction != 0)

      rlc.add(direction);

    // Don't open anything while we're feeding back data

    if (haveBackData()) {

      openSignal = makeOpenSignal();

      if (openSignal != null && openSignal.trigger >= 1)

        openPosition(openSignal);

      afterStep();

    }

  }

  swappable OpenSignal makeOpenSignal() {

    ret opener == null ?: opener.openSignal();

  }

  swappable void beforeStep() {}

  S baseToString() {

    ret colonCombine(

      _conceptID() == 0 ? "" : "Strategy " + _conceptID(),

      "Chaser profit " + formatMarginProfit(coinProfit()));

  }

  S fieldsToReset() {

    ret lines(ll(super.fieldsToReset(), [[lastDirection rlc openSignal]]));

  }

  Chaser emptyClone() {

    Chaser strat = cast super.emptyClone();

    ret strat.opener(opener?.cloneInto(strat));

  }

  // Chaser.toString

  toString { ret baseToString(); } 

  selfType preRunOpener(int minRunUp, int minRunDown) {

    ret opener(new PreRunOpener(minRunUp, minRunDown));

  }

}