sclass TradingCandle {
  // min, max, start and end prices
  settable double min = infinity();
  settable double max;
  settable double start;
  settable double end;
  
  settable Timestamp startTime;
  settable Timestamp endTime;
  settable long projectedEndTime;
  settable bool ongoing;
  
  settable S coin;
  
  double openingPrice aka startingPrice aka open() { ret start; }
  double closingPrice aka endPrice aka close() { ret end; }
  
  selfType open(double x) { ret start(x); }
  selfType close(double x) { ret end(x); }
  selfType high(double x) { ret max(x); }
  selfType low(double x) { ret min(x); }
  
  bool isGreen() {
    ret end > start;
  }
  
  bool isRed() {
    ret end < start;
  }
  
  bool isWhite() {
    ret end == start;
  }
  
  S colorText() {
    ret isGreen() ? "green"
      : isRed() ? "red"
      : "white";
  }
  
  double durationInSeconds() {
    ret toSeconds(endTime.minus(startTime));
  }
  
  void addValue(double price, Timestamp timestamp) {
    if (price < min) min = price;
    if (price > max) max = price;
    end = price;
    endTime = timestamp;
    if (startTime == null) {
      startTime = timestamp;
      start = price;
    }
  }
  
  S myType() { ret "candle"; }
  
  toString {
    S text = firstToUpper(colorText()) + " " + myType();
    if (startTime != null) {
      text += " starting " + startTime + ", duration " +
        iround(toSeconds(endTime.minus(startTime))) + "s";
      text += ", starting price " + formatPrice(start) + ", end price " + formatPrice(end);
      text += ", min " + formatPrice(min) + ", max " + formatPrice(max);
    }
    ret text;
  }
  
  double changeRatio() {
    ret doubleRatio(end, start);
  }
  
  public TradingCandle clone() {
    ret shallowClone(this);
  }
  
  Color color() {
    ret directionToCandleColor(end-start);
  }
  
  double hl2 aka mid() { ret avg(min, max); }
  double delta aka move() { ret end-start; }
  double high() { ret max; }
  double low() { ret min; }
  
  selfType startTime(long startTime) { ret startTime(toTimestamp(startTime)); }
  selfType endTime(long endTime) { ret endTime(toTimestamp(endTime)); }
  
  Timestamp openingTime() { ret startTime; }
  Timestamp closingTime() { ret endTime; }
  
  Timestamp middleTime() { ret new Timestamp((startTime.toLong()+endTime.toLong())/2); }
  
  // whichever one is later
  long endOrProjectedEndTime() {
    ret main max(endTime().unixDate(), projectedEndTime);
  }
}