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);

  }

}