persistable sclass TradingCandleMaker {

  settable double candleLength = 1; // in minutes

  settable int maxCandles = Int.MAX_VALUE;

  settable double alignment; // shift in seconds

  // candleLength = granularity in minutes

  *(double *candleLength) {}

  L<TradingCandle> candles = syncL();

  TradingCandle currentCandle() { ret last(candles); }

  TradingCandle completedCandle() { ret nextToLast(candles); }

  bool isEmpty() { ret main isEmpty(candles); }

  Timestamp endTime() {

    var candle = last(candles);

    ret candle?.endTime();

  }

  double lastPrice() { ret currentCandle().end(); }

  void add(double price, long timestamp) {

    var ts = new Timestamp(timestamp);

    int safety = 0;

    while (currentCandle() != null) {

      if (safety++ >= 1000) {

        warn("TradingCandleMaker safety warning");

        break;

      }

      Timestamp maxEnd = maxEndOfCurrentCandle();

      if (!greaterOrEq(ts, maxEnd)) break;

      currentCandle().endTime(maxEnd);

      double lastPrice = lastPrice();

      newCandle();

      var cc = currentCandle();

      cc.addValue(lastPrice, maxEnd);

      if (cc.projectedEndTime() == 0)

        cc.projectedEndTime(maxEndOfCurrentCandle().unixDate());

    }

    if (empty(candles)) newCandle();

    currentCandle().addValue(price, ts);

  }

  void newCandle {

    var c = currentCandle();

    c?.ongoing(false).projectedEndTime(0);

    candles.add(new TradingCandle().ongoing(true));

    dropOldCandles();

  }

  // returns number of entries processed

  int addTickerSequence aka add aka feed(TickerSequence ts) {

    int entriesProcessed = 0;

    Timestamp endTime = endTime();

    // TODO: Cut off beginning of ticker according to maxCandles

    if (endTime != null)

      ts = ts.subSequenceFromTimestamp(endTime().unixDate()+1);

    int n = l(ts);

    for i to n: {

      add(ts.prices.get(i), ts.timestamps.get(i));

      ++entriesProcessed;

    }

    if (!isEmpty() && ts.lastTickerEvent > currentCandle().endTime().toLong()) {

      add(ts.lastPrice(), ts.lastTickerEvent);

      ++entriesProcessed;

    }

    ret entriesProcessed;

  }

  Timestamp maxEndOfCurrentCandle() {

    long time = currentCandle().startTime.toLong();

    long align = secondsToMS(alignment);

    time = roundUpTo(secondsToMS(candleLength*60), time+align+1)-align;

    ret new Timestamp(time);

  }

  /*bool needNewCandle(long timestamp) {

    ret empty(candles)

      || timestamp >= maxEndOfCurrentCandle().unixDate();

  }*/

  void dropOldCandles {

    if (l(candles) > maxCandles)

      removeSubList(candles, 0, l(candles)-maxCandles);

  }

  L<TradingCandle> candles aka get() { ret cloneList(candles); }

  L<TradingCandle> liveCandles() { ret candles; }

  // only complete candles (cut off last candle and also first candle if incomplete)

  L<TradingCandle> completeCandles() {

    synchronized(mutex()) {

      int startIdx = isComplete(first(candles)) ? 0 : 1;

      ret cloneSubList(candles, startIdx, l(candles)-1);

    }

  }

  // We just synchronize on the candles list

  O mutex() { ret candles; }

  bool isComplete(TradingCandle candle) {

    ret candle != null && candle.durationInSeconds() == candleLength*60;

  }

  toString { ret "Candle maker " + formatDouble(candleLength) + "m, " + nCandles(candles); }

  L<TradingCandle> get(TickerSequence ticker) {

    feed(ticker);

    ret candles();

  }

  selfType granularity(double minutes) {

    ret candleLength(minutes);

  }

}