package gw.rating.rtm.matchop

uses gw.api.database.Query
uses gw.api.database.Relop
uses gw.rating.rtm.domain.OrderedPersistenceAdapter

uses java.lang.Comparable
uses java.math.RoundingMode

@ReadOnly
class StatelessGreaterThanOrEqualMatch extends StatelessMatchOperator {
   construct(matchOp : RateTableMatchOp) {
     super(matchOp)
     initConverter()
  }

  override function compare(bean: OrderedPersistenceAdapter, arg: Comparable<Object>): int {
    var cellValue = bean.get(this.ArgIndex)
    var v : int
    if (cellValue == null) {
      v = 0
    } else {
      v = compareMax(bean, arg)
    }
    return v
  }

  override function needsSubrangeMerge(isNormalized : boolean) : boolean {
    return true
  }

  override public property get OrderDependent() : boolean {
    return true
  }

  override function getScore(bean: OrderedPersistenceAdapter, arg: Comparable<Object>): Comparable<Object> {
    return bean.get(this.ArgIndex) // nonmatching elements are gone, so highest element is what we want
  }

  override function filter(query: Query<KeyableBean>, arg: Comparable<Object>) {
    // DB layer forces us to compare Column to arg rather than the inverse.
    // So this matchop actually computes Column <= arg, not arg >= Column
    query.compare(ColumnName, Relop.LessThanOrEquals, arg)
  }

  override protected function getRounding(paramIndex : int) : RoundingMode {
    // input value 2.5 vs row value 2 should match (2.5 >= 2); vs row value 3 (2.5 >= 3) should not
    // we are actually computing the reverse, i.e. (2 <= 2.5) vs (3 <= 2.5)
    // so we convert input value 2.5 to 2, giving (2 <= 2) and (3 <= 2)
    return FLOOR
  }

  override protected function compareMax(bean : OrderedPersistenceAdapter, arg : Comparable) : int {
    // Return "equal" until we encounter a bean which is > arg
    return bean.get(this.ArgIndex).compareTo(arg) <= 0 ? 0 : 1
  }

  override protected function compareMin(bean : OrderedPersistenceAdapter, arg : Comparable) : int {
    return ACCEPT_ALL_MIN
  }

  override protected function compareMid(bean : OrderedPersistenceAdapter, arg : Comparable) : int {
    return compareMax(bean, arg)
  }

}