concept Corridor extends G22TradingStrategy {
  // how many percent the crypto price needs to move
  // for one profitable trade
  settableWithVar double cellSize = 0.2;
  
  // how many cells the corridor has
  settableWithVar int capacity = 6;
  
  settableWithVar int maxPositionsPerDirection = 4;
  
  settableWithVar bool openTwoPositionsAtStart = true;
  settableWithVar bool alwaysOpenTwoPositions;
  
  // position options
  settableWithVar double leverage = 1;
  settableWithVar double marginPerPosition = 1; // in USDT
  
  // internal
  
  // primed = started but waiting for first price
  settableWithVar bool primed;
  
  settableWithVar PriceDigitizer2 digitizer;
  settableWithVar int direction;
  
  settableWithVar double epsilon = 1e-6;
  
  // maximum debt seen
  settableWithVar double maxDebt;
  //settableWithVar double minCoinProfit;
  //settableWithVar double maxBoundCoin;

  record noeq Position(double openingPrice, double direction, double digitizedOpeningPrice) {
    double closingPrice = Double.NaN;
    long openingStep, closingStep;
    gettable long openingTime;
    gettable long closingTime;
    double leverage;
    settable double cryptoAmount;
    settable O openError;
    settable O closeReason;
    settable O closeError;
    gettable double margin;
    settable bool openedOnMarket;
    settable bool closedOnMarket;
    
    Corridor strategy() { ret Corridor.this; }
    
    {
      // Corridor.this is not set when unstructuring
      if (!dynamicObjectIsLoading()) {
        openingStep = stepCount;
        leverage = Corridor.this.leverage;
        openingTime = currentTime();
      }
    }
    
    double digitizedOpeningPrice() { ret digitizedOpeningPrice; }

    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)/openingPrice*direction*100-adversity)*leverage;
    }
    
    double profit() {
      ret profitAtPrice(closed() ? closingPrice : currentPrice());
    }
    
    double coinProfit() {
      ret profit()/100*margin();
    }
    
    void close(O closeReason) {
      if (closed()) fail("Can't close again");
      if (closeReason != null) closeReason(closeReason);
      openPositions.remove(this);
      closingPrice = currentPrice();
      closingTime = currentTime();
      closingStep = stepCount;
      closedPositions.add(this);
      realizedProfit += profit();
      realizedCoinProfit += coinProfit();
      closeOnMarket();
      //print(this);
      //printPositions();
    }
    
    // Position.toString
    toString {
      ret commaCombine(
        spaceCombine(
          closed() ? "Closed " + formatLocalDateWithSeconds(closingTime()) : null,
          formatDouble1(leverage) + "X " + upper(type())
        ),
        "opened " + formatLocalDateWithSeconds(openingTime()),
        !closed() ? null : or(closeReason, "unknown reason"),
        "profit: " + formatProfit(profit()) + "% (" + marginCoin + " " + plusMinusFix(formatPrice(coinProfit())) + ")",
        "margin: " + marginCoin + " " + formatPrice(margin()),
        "crypto: " + formatPrice(cryptoAmount),
        "opening price: " + formatPriceX(openingPrice)
           + " @ step " + openingStep,
        !closed() ? null : "closing price: " + formatPriceX(closingPrice)
          + " @ step " + closingStep,
        //"digitized: " + formatPrice(digitizedOpeningPrice()),
        );
    }
    
    void closeOnMarket {
      try {
        if (market != null) {
          log("Closing on market: " + this);
          market.closePosition(new IFuturesMarket.CloseOrder()
            .holdSide(HoldSide.fromInt(direction))
            .cryptoAmount(cryptoAmount));
          closedOnMarket(true);
          change();
        }
      } catch e {
        closeError = toPersistableThrowable(e);
      }
    }
    
    void open {
      margin = cryptoAmount*openingPrice/leverage;
      openPositions.add(this);
    }
    
    void openOnMarket {
      try {
        if (market != null) {
          log("Opening on market: " + this);
          market.openPosition(new IFuturesMarket.OpenOrder()
            .holdSide(HoldSide.fromInt(direction))
            .cryptoAmount(cryptoAmount)
            .leverage(leverage)
            .isCross(true));
          openedOnMarket(true);
          change();
        }
      } catch e {
        openError(toPersistableThrowable(e));
        log("Open error:" + e);
        close("Open error");
      }
    }
  }
      
  gettable double currentPrice = 0;
  
  gettable double oldPrice = Double.NaN;
  gettable double startingPrice = Double.NaN;
  gettable int lastDirection;
  gettable double realizedProfit;
  gettable double realizedCoinProfit;
  settableWithVar long stepCount;
  settableWithVar long stepSince;
  gettable new LinkedHashSet<Position> openPositions;
  gettable new L<Position> closedPositions;

  Position openPosition(int direction) {
    if (l(positionsInDirection(direction)) >= maxPositionsPerDirection) {
      log("Not opening new position in direction " + direction + ", max reached");
      null;
    }
    
    var price = digitizedPrice();
    if (isNaN(price)) price = digitizer.digitizeIndividually(currentPrice());
    var p = new Position(currentPrice(), direction, price);
    double cryptoAmount = marginPerPosition/price*leverage;
    cryptoAmount = roundTo(cryptoStep, cryptoAmount);
    p.cryptoAmount = max(minCrypto, cryptoAmount);
    p.open();
    //print("Opening " + p);
    //printPositions();
    p.openOnMarket();
    ret p;
  }
  
  bool hasPosition(double price, double direction) {
    ret findPosition(price, direction) != null;
  }
  
  Position closePosition(double price, double direction, O closeReason) {
    var p = findPosition(price, direction);
    p?.close(closeReason);
    ret p;
  }
  
  void closePositions(Cl<Position> positions, O closeReason default null) {
    forEach(positions, -> .close(closeReason));
  }
  
  Position findPosition(double digitizedPrice, double direction) {
    ret firstThat(openPositions(), p ->
      diffRatio(p.digitizedOpeningPrice(), digitizedPrice) <= epsilon() && 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");
    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);
    //digitizer.init(startingPrice);
    
    print("Starting CORRIDOR at " + startingPrice + " +/- " + cellSize);
    
    if (openTwoPositionsAtStart) {
      nextStep();
      openPosition(1);
      openPosition(-1);
      afterStep();
    }
  }
  
  void prices(double... prices) {
    fOr (price : prices)
      price(price);
  }
  
  swappable PriceCells makePriceCells(double basePrice) {
    //ret new RegularPriceCells(basePrice, cellSize);
    ret new GeometricPriceCells(basePrice, cellSize);
  }
  
  double digitizedPrice() { ret digitizer.digitizedPrice(); }
  double lastDigitizedPrice() { ret digitizer.lastDigitizedPrice(); }
  
  void handleNewPriceInQ(double price) {
    q.add(-> price(price));
  }

  void currentPrice aka price(double price) {
    if (currentPrice == price) ret;
    currentPrice = price;
    
    if (!started()) {
      if (primed) {
        primed(false);
        start();
      }
      ret;
    }
    
    digitizer.digitize(price);
    direction = sign(digitizedPrice()-lastDigitizedPrice());
    
    // No cell move?
    if (direction == 0) ret with afterStep();

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

    if (started())
      step();
      
    print(this);
  }
  
  void nextStep {
    ++stepCount;
    stepSince(now());
  }
  
  swappable void step {
    double p1 = lastDigitizedPrice();
    double p2 = digitizedPrice();
    direction = sign(p2-p1);
    if (direction == 0) ret;
    
    // Find winning positions to close
    
    new L<Position> toClose;
    for (Position p : direction > 0
      ? longPositionsAtOrBelowDigitizedPrice(p1)
      : shortPositionsAtOrAboveDigitizedPrice(p1)) {
      p.closeReason("WIN");
      log("Closing winner position at " + currentPrice + " (" + p1 + " -> " + p2 + "): " + p);
      toClose.add(p);
    }
    
    // Dismantle corridor if too large
    double limit = fromCellNumber(toCellNumber(digitizedPrice())-capacity*direction);
    var toDismantle = direction > 0
      ? shortPositionsAtOrBelowDigitizedPrice(limit)
      : longPositionsAtOrAboveDigitizedPrice(limit);
    print("DISMANTLE LIMIT: " + formatPriceX(limit));
    for (Position p : toDismantle) {
      p.closeReason("DISMANTLE");
      toClose.add(p);
    }
      
    //printVars("step", +p1, +p2, +direction, +closed, +opened);
    
    if (nempty(toClose))
      closePositions(toClose);

    // Open backward position here (if not there yet)
    if (!hasPosition(p2, -direction))
      openPosition(-direction);
      
    // Open forward position if configured as such
    if (alwaysOpenTwoPositions && !hasPosition(p2, direction))
      openPosition(direction);
      
    afterStep();
  }
  
  void afterStep {
    maxDebt = max(maxDebt, debt());
    //minCoinProfit = min(minCoinProfit, coinProfit());
    //maxBoundCoin = max(maxBoundCoin, boundCoin());
    maxInvestment = max(maxInvestment, investment());
    change();
  }
  
  double investment() {
    ret boundCoin()-realizedCoinProfit;
  }
  
  double boundCoin() {
    ret max(openMargins(), max(0, -coinProfit()));
  }
  
  double fromCellNumber(double cellNumber) { ret cells().fromCellNumber(cellNumber); }
  double toCellNumber(double price) { ret cells().toCellNumber(price); }
  
  double unrealizedProfit() {
    double sum = 0;
    for (p : openPositions)
      sum += p.profit();
    ret sum;
  }
  
  double openMargins() {
    double sum = 0;
    for (p : openPositions)
      sum += p.margin();
    ret sum;
  }
  
  double unrealizedCoinProfit() {
    double sum = 0;
    for (p : openPositions)
      sum += p.coinProfit();
    ret sum;
  }
  
  L<Position> positionsInDirection(int direction) {
    ret filter(openPositions, p -> p.direction == direction);
  }
  
  L<Position> longPositions() { ret positionsInDirection(1); }
  L<Position> shortPositions() { ret positionsInDirection(-1); }
  
  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> shortPositionsAtOrBelowDigitizedPrice(double openingPrice) {
    ret filter(openPositions, p -> p.isShort() && p.digitizedOpeningPrice() <= openingPrice);
  }
  
  L<Position> shortPositionsAtOrAboveDigitizedPrice(double openingPrice) {
    ret filter(openPositions, p -> p.isShort() && p.digitizedOpeningPrice() >= openingPrice);
  }
  
  L<Position> longPositionsAtOrAboveDigitizedPrice(double openingPrice) {
    ret filter(openPositions, p -> p.isLong() && p.digitizedOpeningPrice() >= openingPrice);
  }
  
  L<Position> longPositionsAtOrBelowDigitizedPrice(double openingPrice) {
    ret filter(openPositions, p -> p.isLong() && p.digitizedOpeningPrice() <= openingPrice);
  }
  
  L<Position> negativePositions() {
    ret filter(openPositions, p -> p.profit() < 0);
  }
  
  double debt() {
    ret max(0, -unrealizedCoinProfit());
  }
  
  double profit() {
    ret realizedProfit+unrealizedProfit();
  }
  
  double coinProfit() {
    ret realizedCoinProfit+unrealizedCoinProfit();
  }
  
  S baseToString() {
    ret colonCombine(
      _conceptID() == 0 ? "" : "Strategy " + _conceptID(),
      "Corridor");
  }
  
  LS status() {
    var r = currentCorridorPriceRange();
    ret llNonNulls(
      //baseToString(),
      !primed() ? null : "Primed",
      !started() ? null : "Started. current price: " + formatPriceX(currentPrice) + ", digitized: " + formatPriceX(digitizedPrice()),
      "Leverage: " + leverage + ", margin per position: " + marginCoin+ " " + formatPrice(marginPerPosition),
      "Cell size: " + formatPercentage(cellSize, 3) + ", max capacity: " + capacity,
      !started() ? null : "Current corridor: " + (r == null ? "-" : formatPrice(r.start) + " to " + formatPrice(r.end) + " (" + formatPercentage(currentCorridorSizeInPercent(), 3) + ")"),
      "Step " + n2(stepCount) + (stepSince == 0 ? "" : " since " + formatHoursMinutesColonSeconds(currentTime()-stepSince)),
      "Profit: " + marginCoin + " " + plusMinusFix(formatMarginPrice(coinProfit())),
      "Realized profit: " + marginCoin + " " + formatProfit(realizedCoinProfit) + " from " + n2(closedPositions, "closed position"),
      "Unrealized profit: " + marginCoin + " " + formatProfit(unrealizedCoinProfit()) + " in " + n2(openPositions, "open position"),
      "Debt: " + marginCoin + " " + formatProfit(debt()) + " (max seen: " + formatProfit(maxDebt) + ")",
      "Investment used: " + marginCoin + " " + formatMarginPrice(maxInvestment()),
    );
  }
  
  LS fullStatus() {
    ret listCombine(
      status(),
      "",
      n2(openPositions, "open position") + ":",
      reversed(openPositions),
      "",
      n2(closedPositions, "closed position") + ":",
      reversed(closedPositions)
    );
  }
  
  S formatProfit(double x) {
    ret plusMinusFix(formatDouble1(x));
  }
  
  // Corridor.toString
  toString { ret baseToString(); } 
  
  double maxCorridorPercentSize() {
    ret capacity*cellSize;
  }
  
  PriceCells cells() {
    ret digitizer?.cells;
  }
  
  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);
  }

  S formatPriceX(double price) {
    if (isNaN(price)) ret "-";
    double num = cells().priceToCellNumber(price);
    ret formatPrice(price) + " (C" + formatDouble2(num) + ")";
  }
  
  void reset {
    resetFields(this, [[
      digitizer maxDebt direction oldPrice startingPrice              lastDirection realizedProfit realizedCoinProfit
      stepCount
      openPositions closedPositions
    ]]);
    change();
  }
  
  Corridor emptyClone() {
    //var clone = shallowClone(this);
    var clone = shallowCloneToUnlistedConcept(this);
    clone.reset();
    ret clone;
  }
}