sclass Corridor2 {

  settable double smallMove = 0.2;

  settable int capacity = 6;

  settable bool openTwoPositionsAtStart = true;

  record noeq Position(double openingPrice, double direction) {

    double closingPrice = Double.NaN;

    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");

      openPositionsMap(direction).remove(openingPrice);

      closingPrice = currentPrice();

      closedPositions.add(this);

      realizedProfit += profit();

      print(this);

      printPositions();

    }

    toString {

      ret renderFunctionCall(

        spaceCombine(

          closed() ? "Closed" : null,

          type()

        ),

        openingPrice,

        "profit=" + profit());

    }

  }

  gettable double currentPrice = 0;

  gettable double lastPrice = Double.NaN;

  gettable double startingPrice = Double.NaN;

  gettable double realizedProfit;

  gettable double maxDebtEncountered;

  gettable int stepCount;

  // open positions sorted by direction and price

  gettable new TreeMap<Double, Position> openLongs;

  gettable new TreeMap<Double, Position> openShorts;

  gettable new L<Position> closedPositions;

  gettable new DoubleBuffer priceHistory;

  TreeMap<Double, Position> openPositionsMap(double direction) {

    if (direction > 0) ret openLongs;

    if (direction < 0) ret openShorts;

    fail("direction 0");

  }

  Position openPosition(double direction) {

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

    openPositionsMap(direction).put(p.openingPrice, p);

    print("Opening " + p);

    printPositions();

    ret p;

  }

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

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

  L<Position> openPositions() {

    ret concatLists(values(openLongs), values(openShorts));

  }

  void printPositions {

    var positions = openPositions();

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

      joinWithComma(positions)));

  }

  double unrealizedProfit() {

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

  }

  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()); } 

  void prices(double... prices) {

    fOr (price : prices)

      price(price);

  }

  void currentPrice aka price(double price) {

    lastPrice = currentPrice;

    if (lastPrice == price) ret;

    currentPrice = price;

    priceHistory.add(price);

    ++stepCount;

    printWithPrecedingNL(commaCombine(

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

      "New price: " + price));

    step();

    maxDebtEncountered = max(maxDebtEncountered, debt());

    print(this);

  }

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

  void start {

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

    startingPrice = currentPrice();

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

    if (openTwoPositionsAtStart) {

      openPosition(1);

      openPosition(-1);

    }

  }

  int currentDirection() {

    ret sign(currentPrice-lastPrice);

  }

  L<Position> positionsAtPriceOrWorse(double direction, double price) {

    var map = openPositionsMap(direction);

    ret direction < 0

      ? valuesList(map.tailMap(price, true))

      : valuesList(map.headMap(price, true));

  }

  // Algorithm-specific logic follows

  swappable void step {

    // Close winning position(s)

    var positions = positionsAtPriceOrWorse(currentDirection(),

      currentPrice()-currentDirection()*smallMove);

    for (p : positions) p.close();

    // If we closed anything, open a position in reverse direction

    if (nempty(positions)) {

      openPosition(-currentDirection());

    }

    // TODO: "travelling"

  }

}