package gw.rating.rtm.matchop

uses gw.api.util.TypeUtil

uses java.lang.Comparable
uses java.util.Arrays
uses java.lang.IllegalArgumentException

class MultipleParam<T extends Comparable> implements CompoundParam<T> {
  var convertedValues : T[]
  var sval : String

  construct(values : T[], toStringVal : String = null) {
    if (values.allMatch(\ v -> v == null)) throw new IllegalArgumentException("Don't create a compound param that is all nulls")
    convertedValues = values
    sval = toStringVal ?: "[" + values.map(\ v -> v?.toString()).join(", ") + "]"
  }

  override function toString(): String {
    return sval
  }

  override function getValue(ix : int) : T {
    return convertedValues[ix]
  }

  override property get First() : T {
    return convertedValues[0]
  }

  override property get Second() : T {
    return convertedValues[1]
  }

  override property get NumValues() : int {
    return convertedValues.length
  }

  override function compareTo(o: CompoundParam<T>) : int {
    if (this === o) return 0

    if (o typeis RangeParam <T>) {
      // RangeParam knows how to compare to MultipleParam provided NumValues == 2
      return - o.compareTo(this)
    }

    for (i in 0..|java.lang.Math.min(NumValues, o.NumValues)) {
      var a = getValue(i)
      var b = o.getValue(i)
      if (a === b) continue // identical references, or both null
      if (not TypeUtil.isNominallyOrStructurallyAssignable(typeof a, typeof b)) {
        throw new java.lang.IllegalArgumentException("Types do not match: ${typeof a} vs ${typeof b}" )
      }

      var n = a.compareTo(b)
      if (n != 0) {
        return n
      }
    }

    return NumValues - o.NumValues // if they're not identical, shorter one < longer one
  }

  override function equals(o : Object) : boolean {
    if (this === o) return true

    if (o typeis CompoundParam<T> and NumValues == 2 and o.NumValues == 2) {
      return (First == o.First and Second == o.Second)
    } else if (o typeis MultipleParam<T>) {
      return Arrays.deepEquals(convertedValues, o.convertedValues)
    } else {
      return false
    }
  }

  static var hashcode_weights : int[] = {31, 11, 19, 11, 17, 7, 29, 13}
  static function computeHash(values : Comparable[]) : int {
    var n = 0
    for (i in 0..|values.length) {
      n = hashcode_weights[i%8]!*n !+ values[i]?.hashCode()
    }
    return n
  }

  override function hashCode() : int {
    return computeHash(convertedValues)
  }
}