sclass MPM {
  gettable new PositionSet imaginaryPositions;
  gettable new PositionSet realPositions;
  
  settable double cryptoPrice;
  new DoubleBuffer cryptoPriceLog;
  // -1, 0 [initial value only] or 1
  settable int cryptoDirection;
  event cryptoDirectionChanged;
  
  settable double currentTime;
  
  settable double maxAllowedLoss = 1; // in percent

  Position newShort() { ret new Position().direction(-1); }
  Position newLong()  { ret new Position().direction(1); }

  abstract class CloseReason {}
  class LossClose > CloseReason {}
  class HappyClose > CloseReason {}
  class RegularClose > CloseReason {} // pullback close
  class KillClose > CloseReason {} // hard-closed for any reason
  
  settable double fees = 0.12;
  settable double expectedSlippage = .1; // in percent before leverage
  
  class Position {
    settable bool real;

    // -1 (short) or 1 (long)
    settable int direction;
    
    settable double openingTime;
    settable double openingPrice;
    settable double lastPrice;
    settable double closingTime;
    settable double closingPrice;
    
    simplyCached double openingPriceWithFeesAndSlippage() {
      ret openingPrice*(1+(fees+expectedSlippage)/100*direction);
    }

    settable double relativeValue;    
    settable double maxRelativeValue = negativeInfinity();
    settable double minRelativeValue = infinity();
    settable double pullbackThreshold;

    // null when position is open, not null when position was closed
    settable CloseReason closeReason;
    
    PositionSet motherList() {
      ret real ? realPositions : imaginaryPositions;
    }
    
    void close(CloseReason reason) {
      closingTime(time());
      closingPrice(cryptoPrice);
      closeReason(reason);
      motherList().wasClosed(this);
    }
    
    void imagine {
      real(false);
      launch();
    }
    
    void launch {
      update(cryptoPrice);
      motherList().add(this);
    }
    
    void update(double cryptoPrice) {
      lastPrice(cryptoPrice);
      relativeValue((cryptoPrice/openingPriceWithFeesAndSlippage()-1)*direction*100);
      maxRelativeValue(max(maxRelativeValue, relativeValue));
      minRelativeValue(min(minRelativeValue, relativeValue));
      pullbackThreshold(maxRelativeValue-pullback(this));
    }
    
    toString {
      ret renderVars(+direction, +openingPrice, +openingPriceWithFeesAndSlippage(), +lastPrice, +relativeValue, +maxRelativeValue);
    }
    
    void autoClose {
      if (relativeValue < -maxAllowedLoss)
        ret with close(new LossClose);
        
      if (relativeValue >= 0
        && relativeValue < pullbackThreshold)
        ret with close(new RegularClose);
    }
    
    bool isOpen() { ret closeReason == null; }
  } // end of Position
  
  class PositionSet {
    new LinkedHashSet<Position> positionsByDate;
    new LinkedHashSet<Position> openPositions;
    new LinkedHashSet<Position> closedPositions;
    
    void add(Position p) {
      positionsByDate.add(p);
      (p.isOpen() ? openPositions : closedPositions).add(p);
    }
    
    void remove(Position p) {
      positionsByDate.remove(p);
      openPositions.remove(p);
      closedPositions.remove(p);
    }
    
    void wasClosed(Position p) {
      openPositions.remove(p);
      closedPositions.add(p);
    }
  }
  
  swappable double pullback(Position p) { ret 0.5; }
  
  double time() {
    ret currentTime;
  }
  
  void addTickerSequence(TickerSequence ts) {
    int n = l(ts);
    for i to n:
      newCryptoPrice(ts.prices.get(i), ts.timestamps.get(i));
  }
  
  void newCryptoPrice(double price) {
    newCryptoPrice(price, currentTime+1);
  }
  
  void newCryptoPrice(double price, double time) {
    currentTime(time);
  
    // don't store non-changes
    if (price == cryptoPrice) ret;
    
    int direction = sign(cryptoPrice-price);
    cryptoPriceLog.add(price);
    cryptoPrice(price);
    
    for (p : allOpenPositions()) {
      p.update(cryptoPrice);
      p.autoClose();
    }
    
    if (direction != cryptoDirection) {
      cryptoDirection(direction);
      cryptoDirectionChanged();
    }
  }
  
  L<Position> allPositions() {
    ret concatLists(realPositions().positionsByDate, imaginaryPositions().positionsByDate);
  }
  
  L<Position> allOpenPositions() {
    ret concatLists(realPositions().openPositions, imaginaryPositions().openPositions);
  }
  
  { init(); }
  
  void init {
    onCryptoDirectionChanged(-> {
      for (p : ll(newLong(), newShort()))
        p.openingTime(time()).openingPrice(cryptoPrice).imagine();
    });
  }
  
  void printStatus {
    print(toString());
  }
  
  toString {
    ret combineWithSeparator(" + ",
      n2(realPositions.positionsByDate, "real position"),
      n2(imaginaryPositions.positionsByDate, "imaginary position"));
  }
}