concept Corridor extends G22TradingStrategy {
  // how many cells the corridor has
  settableWithVar int capacity = 3;
  
  settableWithVar int maxPositionsPerDirection = 100;

  settableWithVar bool instantRestart = true;
  
  // initial position behavior
  settableWithVar bool openTwoPositionsAtStart;
  settableWithVar bool openRandomPositionAtStart = true;
  settableWithVar int openFixedDirectionAtStart; // 1 or -1 or 0
  
  // later position opening behavior
  settableWithVar bool alwaysOpenTwoPositions;
  
  // Pre-run to check if coin is in corridor mode (dev.)
  //settableWithVar bool usePreRun;
  //settableWithVar AbstractJuicer preRunJuicer;
  
  settableWithVar bool endStrategyWhenCapacityExceeded = true;
  
  settableWithVar bool useStrategyJuicer;
  !include #1036390 // MultiPullbackJuicer maker include
  settableWithVar SignalWithStrength closeSignal;
  
  // internal
  
  persistable class Position extends G22TradingStrategy.Position {
  }
  
  // direction: -1 or 1 for normal short or long
  // To change size of of position, use -2, 2 etc
  Position openPosition(int direction) {
    if (l(positionsInDirection(direction)) >= maxPositionsPerDirection) {
      log("Not opening new position in direction " + direction + ", max reached");
      null;
    }
    
    new Position p;
    p.marginToUse = marginPerPosition*abs(direction);
    ret openPosition(p, direction);
  }

  void start {
    if (started()) fail("Already started");
    if (currentPrice() == 0)
      ret with primed(true);
    
    // Save starting price, create price cells & digitizer
    
    startingPrice = currentPrice();
    startTime = currentTime();
    var priceCells = makePriceCells(startingPrice);
    print("Made price cells: " + priceCells);
    digitizer = new PriceDigitizer2(priceCells);
    digitizer.verbose(verbose);
    //digitizer.init(startingPrice);
    
    makeStrategyJuicer();
    
    log("Starting CORRIDOR at " + startingPrice + " +/- " + cellSize);
    
    startAction();
  }
  
  swappable void startAction {
    if (openTwoPositionsAtStart) {
      nextStep();
      openPosition(1);
      openPosition(-1);
      afterStep();
    } else if (openRandomPositionAtStart) {
      nextStep();
      log("Opening random initial position.");
      openPosition(securelyTossCoin() ? 1 : - 1);
      afterStep();
    } else if (openFixedDirectionAtStart != 0) {
      nextStep();
      log("Opening fixed initial position.");
      openPosition(sign(openFixedDirectionAtStart));
      afterStep();
    }
  }
  
  void price(double price) {
    if (currentPrice == price) ret;
    currentPrice = price;
    
    if (hasClosedItself()) ret;
    
    if (!started()) {
      if (primed) {
        primed(false);
        start();
      } else
        ret;
    }
    
    digitizer.digitize(price);
    direction = sign(digitizedPrice()-lastDigitizedPrice());
    
    if (applyStrategyJuicer()) ret;
    
    // No cell move?
    if (direction == 0) ret with afterStep();

    nextStep();
    //printWithPrecedingNL("New digitized price: " + digitizedPrice());

    if (started())
      step();
      
    print(this);
  }
  
  // true if exit
  bool applyStrategyJuicer() {
    // Check strategy juicer
    closeSignal(strongestSignal(strategyJuicer?.calculateCloseSignals()));
    if (closeSignal != null && closeSignal.isTrigger()) {
      log("Juicer close signal! " + closeSignal);
      closeOrRestart();
      afterStep();
      true;
    }
    
    false;
  }
  
  swappable void step {
    double p1 = lastDigitizedPrice();
    double p2 = digitizedPrice();
    direction = sign(p2-p1);
    if (direction == 0) ret;
    
    // Find winning positions to close
    
    L<G22TradingStrategy.Position> toClose = new L;
    for (p : direction > 0
      ? longPositionsAtOrBelowDigitizedPrice(p1)
      : shortPositionsAtOrAboveDigitizedPrice(p1)) {
      cast p to Position;
      p.closeReason("WIN");
      log("Closing winner position at " + formatPriceX(currentPrice) + " (" + p1 + " -> " + p2 + "): " + p);
      toClose.add(p);
    }
    
    // Dismantle/close corridor if too large
    double limit = fromCellNumber(toCellNumber(digitizedPrice())-capacity*direction);
    var toDismantle = direction > 0
      ? shortPositionsAtOrBelowDigitizedPrice(limit)
      : longPositionsAtOrAboveDigitizedPrice(limit);
    if (logToPrint) printVars(dismantleLimit := formatPriceX(limit),
      +direction,
      +capacity,
      +digitizedPrice(),
      +toDismantle);
    
    if (nempty(toDismantle)) {
      if (endStrategyWhenCapacityExceeded) {
        log("Capacity exceeded!");
        closeOrRestart();
        afterStep();
        ret;
      } else {
        for (p : toDismantle) {
          cast p to Position;
          p.closeReason("DISMANTLE");
          toClose.add(p);
        }
      }
    }
      
    //printVars("step", +p1, +p2, +direction, +closed, +opened);
    
    if (nempty(toClose))
      closePositions(toClose);

    // Apply take profits etc BEFORE possibly opening a new position
    afterStep();
    
    openNewPositionAfterMove();
      
    // Apply take profits, stop loss etc
    afterStep();
  }
  
  void closeOrRestart {
    if (instantRestart)
      restart();
    else
      closeMyself();
  }
  
  void restart {
    closeMyself();
    active(true);
    closedItself(0);
    startAction();
  }

  swappable void openNewPositionAfterMove {  
    // Open backward position here (if not there yet)
    openPositionIfNotThere(-direction);
      
    // Open forward position if configured as such
    if (alwaysOpenTwoPositions)
      openPositionIfNotThere(direction);
  }
  
  Position openPositionIfNotThere(int direction) {
    if (!hasPosition(digitizedPrice(), direction))
      ret openPosition(direction);
    else
      null;
  }
  
  swappable S mainDesc() {
    try answer renderCustomName();

    ret capacity + "x" + formatCellSize(cellSize) + " Corridor";
  }
  
  S baseToString() {
    ret colonCombine(
      _conceptID() == 0 ? "" : "Strategy " + _conceptID(),
      spaceCombine(
        squareBracketUnlessEmpty(areaDesc()),
        mainDesc(),
        nempty(cryptoCoin) ? "on " + cryptoCoin : ""
      ),
    );
  }
  
  LS status() {
    var r = currentCorridorPriceRange();
    ret listCombine(
      super.status(),
      "Max capacity: " + capacity,
      !started() ? null : "Current corridor: " + (r == null ? "-" : formatPrice(r.start) + " to " + formatPrice(r.end) + " (" + formatPercentage(currentCorridorSizeInPercent(), 3) + ")"),
      "Profit unit: " + formatMarginPrice(profitUnitBeforeAdversity()) + "/" + marginCoin + " " + formatMarginPrice(profitUnitAfterAdversity()) + ", loss unit: " + marginCoin + " " + formatMarginPrice(lossUnit()),
      closeSignal == null ?: "Close signal: " + closeSignal,
    );
  }
  
  // Corridor.toString
  toString {
    ret baseToString();
  } 
  
  S renderCustomName() {
    ret empty(customName) ? null : simpleQuoteOpt(trim(customName));
  }
  
  double maxCorridorPercentSize() {
    ret capacity*cellSize;
  }
  
  DoubleRange currentCorridorPriceRange() {
    double[] openingPrices = mapToDoubleArray(openPositions, ->.openingPrice);
    ret doubleRange(doubleMin(openingPrices), doubleMax(openingPrices));
  }
  
  double currentCorridorSizeInPercent() {
    DoubleRange r = currentCorridorPriceRange();
    ret r == null ? 0 : asPercentIncrease(r.end, r.start);
  }

  Position openShort() { ret openPosition(-1); }
  Position openLong() { ret openPosition(1); }
  
  {
    cellSize(3.0);
  }
  
  double positionSize() { ret marginPerPosition*leverage; }
  double profitUnitBeforeAdversity() { ret cellSize/100*positionSize(); }
  double profitUnitAfterAdversity() { ret (cellSize-adversity)/100*positionSize(); }
  double lossUnit() { ret (cellSize+adversity)/100*positionSize(); }
  
  // Uses profit calculated in profit units
  // (could alternatively use investment units, but like this the
  // loss ratio should stay more consistent between coins [=leverage values])
  class ProfitUnitsJuiceable is Juiceable {
    public double juiceValue() {
      ret coinProfit()/profitUnitBeforeAdversity();
    }
  }
  
  // Update strategy juicer if it exists
  void updateStrategyJuicer {
    if (strategyJuicer != null) {
      makeStrategyJuicer();
      applyStrategyJuicer();
    }
  }
  
  // Can also update existing juicer with new params
  void makeStrategyJuicer {
    if (!useStrategyJuicer) ret with strategyJuicer(null);
    var j = makeJuicer();
    j.copyTransientValuesFrom(strategyJuicer);
    j.juiceable(new ProfitUnitsJuiceable);
    strategyJuicer(j);
  }
  
  S fieldsToReset() {
    ret lines(ll(super.fieldsToReset(), [[closeSignal strategyJuicer]]));
  }
  
  double currentCellNumber() {
    ret toCellNumber(currentPrice());
  }
  
  // Cell we're in
  int currentDigitizedCell() {
    ret iround(toCellNumber(digitizedPrice()));
  }
  
  int priceDirection() {
    ret sign(currentCellNumber()-currentDigitizedCell());
  }
  
  // Cell we're currently moving to
  int targetCell() {
    ret currentDigitizedCell()+priceDirection();
  }
  
  double targetPrice() {
    ret fromCellNumber(targetCell());
  }
  
  // Coin profit when next target is reached
  double targetProfit() {
    ret coinProfitAtPrice(targetPrice());
  }
  
  // Is profit currently going up or down
  int profitDirection() {
    ret sign(targetProfit()-coinProfit());
  }
  
  // progress to next target in percent
  double progressInProfitDirection() {
    ret absDiff(currentCellNumber(), currentDigitizedCell())*100;
  }
}