set flag Reparse.

sclass Corridor {

  settable double ladderStep = 1;

  settable int capacity = 6;

  settable bool openTwoPositionsAtStart = true;

  record noeq Position(double openingPrice, double direction) {

    double closingPrice = Double.NaN;

    int digitizedOpeningPrice() { ret digitizePrice(openingPrice); }

    bool isLong() { ret direction > 0; }

    bool isShort() { ret direction < 0; }

    bool closed() { ret !isNaN(closingPrice); }

    S type() { ret trading_directionToPositionType(direction); }

    double profitAtPrice(double price) {

      ret (price-openingPrice)*direction;

    }

    double profit() {

      ret profitAtPrice(closed() ? closingPrice : currentPrice());

    }

    void close {

      if (closed()) fail("Can't close again");

      openPositions.remove(this);

      closingPrice = currentPrice();

      closedPositions.add(this);

      realizedProfit += profit();

      print(this);

      printPositions();

    }

    toString {

      ret renderFunctionCall(

        spaceCombine(

          closed() ? "Closed" : null,

          type()

        ),

        openingPrice + " [" + digitizedOpeningPrice() + "]",

        "profit=" + profit());

    }

  }

  gettable double currentPrice = 0;

  gettable double oldPrice = Double.NaN;

  gettable double startingPrice = Double.NaN;

  gettable double digitizationBase;

  gettable int lastDirection;

  gettable double realizedProfit;

  gettable int stepCount;

  gettable new LinkedHashSet<Position> openPositions;

  gettable new L<Position> closedPositions;

  gettable new DoubleBuffer priceHistory;

  Position openPosition(double direction) {

    var p = new Position(currentPrice(), direction);

    openPositions.add(p);

    print("Opening " + p);

    printPositions();

    ret p;

  }

  bool hasPosition(double price, double direction) {

    ret findPosition(price, direction) != null;

  }

  Position closePosition(double price, double direction) {

    var p = findPosition(price, direction);

    p?.close();

    ret p;

  }

  Position findPosition(double price, double direction) {

    ret firstThat(openPositions(), p ->

      p.digitizedOpeningPrice() == digitizedPrice(price) && p.direction == direction);

  }

  Position openShort() { ret openPosition(-1); }

  Position openLong() { ret openPosition(1); }

  void printPositions {

    print(colonCombine(n2(openPositions, "open position"),

      joinWithComma(openPositions)));

  }

  bool started() { ret !isNaN(startingPrice); }

  void start {

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

    startingPrice = currentPrice();

    digitizationBase = frac(startingPrice/ladderStep);

    print("Starting CORRIDOR at " + startingPrice + " +/- " + ladderStep);

    if (openTwoPositionsAtStart) {

      openPosition(1);

      openPosition(-1);

    }

  }

  int digitizePrice aka digitizedPrice(double price) {

    ret iround((price-digitizationBase)/ladderStep);

  }

  int oldPriceDigitized() {

    ret digitizePrice(oldPrice);

  }

  int currentPriceDigitized() {

    ret digitizePrice(currentPrice());

  }

  void prices(double... prices) {

    fOr (price : prices)

      price(price);

  }

  void currentPrice aka price(double price) {

    oldPrice = currentPrice;

    if (oldPrice == price) ret;

    currentPrice = price;

    int direction = sign(price-oldPrice);

    lastDirection = direction;

    if (oldPriceDigitized() == currentPriceDigitized()) ret;

    bool first = empty(priceHistory);

    priceHistory.add(price);

    ++stepCount;

    if (first)

      printWithPrecedingNL("Starting price: " + price);

    else

      printWithPrecedingNL(commaCombine(

        "Step " + stepCount + ". Old price: " + oldPrice,

        "New price: " + price));

    if (started())

      step();

    print(this);

  }

  swappable void step {

    // Close forward position "behind us"

    closePosition(currentPrice()-ladderStep*lastDirection(), lastDirection());

    int p1 = oldPriceDigitized();

    int p2 = currentPriceDigitized();

    // Open backward position here (if not there yet)

    int direction = lastDirection();

    if (!hasPosition(currentPrice(), -direction))

      openPosition(-direction);

  }

  double unrealizedProfit() {

    ret doubleSum(map(openPositions, ->.profit()));

  }

  L<Position> shortPositionsAtOrBelowPrice(double openingPrice) {

    ret filter(openPositions, p -> p.isShort() && p.openingPrice <= openingPrice);

  }

  L<Position> longPositionsAtOrAbovePrice(double openingPrice) {

    ret filter(openPositions, p -> p.isLong() && p.openingPrice >= openingPrice);

  }

  L<Position> negativePositions() {

    ret filter(openPositions, p -> p.profit() < 0);

  }

  double debt() {

    ret doubleSum(map(negativePositions(), ->.profit()));

  }

  double profit() {

    ret realizedProfit+unrealizedProfit();

  }

  LS status() {

    ret ll(

      "Step " + n2(stepCount),

      "Profit: " + profit(),

      "Realized profit: " + realizedProfit + " from " + n2(closedPositions, "closed position"),

      "Unrealized profit: " + unrealizedProfit() + " in " + n2(openPositions, "open position"),

      "Debt: " + debt(),

    );

  }

  toString { ret commaCombine(status()); } 

}