package gw.financials
uses java.lang.Comparable

/**
 * An enum-equivalent of all (8) possible combinations of written, charged, and to-be-accrued booleans
 */
class WCA implements Comparable<WCA> {

  private var _written : boolean as readonly Written
  private var _charged : boolean as readonly Charged
  private var _accrued : boolean as readonly Accrued
  
  private static var _all : WCA[] = initializeAll()
  
  /* Enum pattern. */
  private construct(w : boolean, c : boolean, a: boolean) {
    _written = w
    _charged = c
    _accrued = a
  }
  
  public static function of(written : boolean, charged : boolean, accrued : boolean) : WCA {
    var idx = indexOf(written, charged, accrued)
    return _all[idx]
  }
  
  private static function indexOf(w : boolean, c : boolean, a : boolean) : int {
    return (w ? 1 : 0) + (c ? 2 : 0) + (a ? 4 : 0)
  }
  
  private static function initializeAll() : WCA[] {
    var result = new WCA[8]
    var initElement : block(w : boolean, c : boolean, a : boolean) = \ w,c,a -> {result[indexOf(w,c,a)] = new WCA(w,c,a)}
    initElement(false, false, false)
    initElement(false, false,  true)
    initElement(false,  true, false)
    initElement(false,  true,  true)
    initElement( true, false, false)
    initElement( true, false,  true)
    initElement( true,  true, false)
    initElement( true,  true,  true)
    return result
  }

  override function compareTo(that: WCA) : int {
    switch (true) {
      case this.Written != that.Written: return Written ? -1 : 1
      case this.Charged != that.Charged: return Charged ? -1 : 1
      case this.Accrued != that.Accrued: return Accrued ? -1 : 1
      default:
        return 0
    }
  }
  
  override function toString() : String {
    return  (Written ? "W" : "") + (Charged ? "C" : "") + (Accrued ? "A" : "")
  }


}