package gw.rating.rtm.valueprovider

uses java.lang.Comparable
uses java.util.Map
uses java.util.LinkedHashMap
uses gw.api.productmodel.GenericCovTermPattern
uses gw.api.productmodel.OptionCovTermPattern
uses gw.api.productmodel.PackageCovTermPattern
uses gw.api.productmodel.TypekeyCovTermPattern
uses gw.entity.TypeKey
uses gw.api.productmodel.CovTermPatternVisitor
uses gw.api.productmodel.DirectCovTermPattern
uses gw.api.productmodel.CovTermPattern
uses java.util.List

uses gw.rating.rtm.domain.PersistenceAdapter
uses gw.rating.rtm.domain.table.RateTableCell
uses gw.api.productmodel.ProductModelClass

/**
 * An abstract base class for value providers that retrieve coverage term options
 * from PC product model. It implements functionality common for Option, Package,
 * Typekey and Generic coverage term patterns.
 */
abstract class AbstractCovTermOptionValueProvider extends AbstractProductModelValueProvider {

  // key: covcode + covtermcode
  // value: a map of option code -> option label
  protected var _cache : Map<Key, Map<String, String>>

  /**
   * @param column  rate table column definition
   */
  construct(column : RateTableColumn) {
    super(column)
    _cache = new LinkedHashMap<Key, Map<String, String>>()
  }

  /**
   * Returns coverage term code from a <code>bean</code> based on rate table column
   * definition and its dependency.
   *
   * @param bean  physical bean that stores rate table row (a set of rate
   *              table parameters and factor(s).
   * @returns coverage term code.
   */
  abstract function getCovTermCode(adapter : PersistenceAdapter) : String

  /**
   * Returns coverage code from a <code>bean</code> based on rate table column
   * definition and its dependency.
   *
   * @param bean  physical bean that stores rate table row (a set of rate
   *              table parameters and factor(s).
   * @returns coverage code.
   */
  abstract function getCovCode(adapter : PersistenceAdapter) : String

  override function convertCodeIdentifierToPublicID(str : String) : String {
      return str.Empty ? null : String.valueOf(str)
  }

  override function getDependentValues(dependencies : String[]) : Map<String, String> {
    return dependencies.length > 1 ? getValueMap(dependencies): {}
  }

  override function getDependentValuesAsTypeKeys(args : String[])   : List<TypeKey> {
    if (args.length < 2) return {}

    var covCode = args[0]
    var covTermCode = args[1]

    var covPattern = PolicyLinePattern.getCoveragePatternByPublicId(covCode)
    if (covPattern == null) return {}

    var covTermPattern = covPattern.CovTerms.firstWhere(\ covTerm -> covTerm.PublicID == covTermCode)
    if (covTermPattern == null) return {}


    if (covTermPattern typeis TypekeyCovTermPattern) {
      return covTermPattern.TypeList.getTypeKeys(false)
    }

    return {}
  }

  /**
   * @see gw.rating.rtm.valueprovider.RateTableCellValueProvider#getValues(KeyableBean)
   */
  override function getValues(adapter : PersistenceAdapter) : String[] {
    var covTermCode = getCovTermCode(adapter)
    if (covTermCode == null) return {}
    var covCode = getCovCode(adapter)
    if (covCode == null) return {}

    return getValueMap({covCode, covTermCode}).Keys.toTypedArray()
  }

  function containsCodeFor(cell : RateTableCell) : boolean {
    var covTermCode = getCovTermCode(cell.Adapter)
    if (covTermCode == null) return false
    var covCode = getCovCode(cell.Adapter)
    if (covCode == null) return false

    return getValueMap({covCode, covTermCode}).containsKey((cell.Value as String))
  }

  override function getValueMap(args: String[]) : Map<String, String> {
    var covCode = args[0]
    var covTermCode = args[1]

    var covPattern = PolicyLinePattern.getCoveragePatternByPublicId(covCode)
    if (covPattern == null) return {}
    var covTermPattern = covPattern.CovTerms.firstWhere(\ covTerm -> covTerm.PublicID == covTermCode)
    if (covTermPattern == null) return {}

    var key = new Key(covCode, covTermCode)
    var values = _cache.get(key) ?: makeValueMap(covTermPattern)
    _cache.put(key, values)
    return values
  }

  private function makeValueMap(covTermPattern : CovTermPattern) : Map<String, String> {
    var valueMapMaker = new ValueMapMakerVisitor(ColumnDefinition)
    covTermPattern.acceptVisitor(valueMapMaker)
    return valueMapMaker.SortedMap
  }

  static class ValueMapMakerVisitor implements CovTermPatternVisitor {
    var _columnDefinition : RateTableColumn
    var _sortedMap: LinkedHashMap<String, String> as readonly SortedMap = {}

    construct(columnDefinition : RateTableColumn) {
      _columnDefinition = columnDefinition
    }

    override function visit(pattern : PackageCovTermPattern) {
      pattern.Packages
          .sortBy(\ pkg -> pkg.Priority)
          .each(\ pkg -> _sortedMap.put(pkg.PackageCode, pkg.DisplayName))
    }

    override function visit(pattern : OptionCovTermPattern) {
      pattern.Options
          .sortBy(\ option -> option.Priority)
          .each(\ option -> _sortedMap.put(option.OptionCode, option.DisplayName))
    }

    override function visit(pattern : TypekeyCovTermPattern) {
      pattern.OrderedAvailableValues
          .each(\ v -> _sortedMap.put(v.Code, v.DisplayName))
    }

    override function visit(pattern : DirectCovTermPattern) {
      // I'm not sure if we should throw here, but the original behavior was to do nothing so,...
    }

    override function visit(pattern : GenericCovTermPattern) {
      var boolValueProvider = new BooleanValueProvider(_columnDefinition)
      boolValueProvider.getValues(null)
          .each(\ v -> _sortedMap.put(v, boolValueProvider.valueByCode(null, v)))
    }

  }

  /**
   * @see gw.rating.rtm.valueprovider.RateTableCellValueProvider#valueByCode(KeyableBean, String)
   */
  override function valueByCode(adapter : PersistenceAdapter, code : String) : String {
    var covTermCode = getCovTermCode(adapter)
    if (covTermCode == null) return code
    var covCode = getCovCode(adapter)
    if (covCode == null) return code

    var key = new Key(covCode, covTermCode)
    var v = _cache.get(key)
    return v != null ? v.get(code) : ""
  }


  private class Key implements Comparable {
    private var _covCode : String as readonly CovCode
    private var _covTermCode : String as readonly CovTermCode

    construct(cov : String, covterm : String) {
      _covCode = cov
      _covTermCode = covterm
    }

    override function compareTo(other : Object) : int {
      if (other typeis Key) {
        var covCompare = _covCode.compareTo(other.CovCode)
        if (covCompare != 0) return covCompare
        return _covTermCode.compareTo(other.CovTermCode)
      }
      return 1
    }

    override function toString() : String {
      return "${_covCode}/${_covTermCode}"
    }

    override function equals(other : Object) : boolean {
      if (this === other) {
        return true
      }
      return
        other typeis Key
        and this._covCode == other._covCode
        and this._covTermCode == other._covTermCode
    }

    override function hashCode() : int {
      var prime = 31
      var result = 1
      result = prime * result + (_covCode == null ? 0 : _covCode.hashCode())
      result = prime * result + (_covTermCode == null ? 0 : _covTermCode.hashCode())
      return result
    }
  }

  override property get ProductModelType() : Type<ProductModelClass> {
    return OptionCovTermPattern.Type
  }
}