package gw.rating.rtm.valueprovider

uses gw.api.locale.DisplayKey
uses gw.api.productmodel.CoveragePattern
uses gw.api.productmodel.PolicyLinePattern
uses gw.api.productmodel.ProductModelClass
uses gw.rating.rtm.domain.PersistenceAdapter
uses gw.rating.rtm.domain.table.RateTableCell
uses gw.rating.rtm.matchop.CoverageParam
uses gw.rating.rtm.util.AvailableAttributePresenter

/**
 * Value provider implementation for policy line coverages configured in PC product model.
 */
class CoverageValueProvider extends AbstractProductModelValueProvider {

  protected var _cache : Map<String, String>
  var cachedValueSet : Set<String>

  construct(column : RateTableColumn) {
    super(column)
    _cache = new LinkedHashMap<String, String>()
  }

  /**
   * Returns an array of coverage codes for a particular policy line.
   * 
   * @param bean  is not used
   * @returns an array of all coverage codes (both available and not) for a policy line.
   */
  override function getValues(adapter : PersistenceAdapter) : String[] {
    return getValueMap(null).Keys.toTypedArray()
  }

  /**
   * Returns a displayable label for a coverage code. The label is defined in
   * <code>Web.Rating.CoverageValueProvider.DisplayLabel</code> display key and consists of
   * coverage category name and coverage name.
   * 
   * @param bean  is not used
   * @param code  a string code, one of the codes returned by {@link #getValues getValues} method.
   * @returns a displayable string.
   */
  override function valueByCode(adapter : PersistenceAdapter, code : String) : String {
    if (!_cache.containsKey(code)) {
      getValues(adapter)
    }
    return _cache.get(code)
  }

  function containsCodeFor(cell : RateTableCell) : boolean {
    if (cachedValueSet == null) {
      cachedValueSet = getValues(cell.Adapter).toSet()
    }

    return cell.cellValueContainsCode(cachedValueSet)
  }

  protected function createDefaultAttributePresenter(cov : entity.CalcRoutineParameter) : AvailableAttributePresenter {
    if (cov.UseWrapper) {
      return new AvailableAttributePresenter(cov.Code, "PatternCode", false, DisplayKey.get("Web.Rating.CoverageValueProvider.WrapperPatternCode", cov.Code.DisplayName))
    }
     return new AvailableAttributePresenter(cov.Code, cov.CoveragePattern == null ? "Coverage" : cov.CoveragePattern, false, cov.Code.DisplayName)
  }
  
  override function availableAttributes(line : PolicyLinePattern, paramSet : CalcRoutineParameterSet) : List<AvailableAttributePresenter> {
    var coverages = paramSet == null ? Collections.emptyList<CalcRoutineParameter>() : paramSet.Parameters.where(\ p -> p.ParamType == "entity.Coverage").toList()
    if (coverages.Count > 1) {
      return coverages.map(\ cov ->  createDefaultAttributePresenter(cov)) 
    } else  {
      var cov = coverages.first()
      return Collections.singletonList<AvailableAttributePresenter>(createDefaultAttributePresenter(cov))
    }
  }

  override function getQueryParamValue(cov : Coverage) : String {
    return cov.PatternCode
  }

  override function getQueryParam(cov : Coverage) : CoverageParam {
    var patternCode = getQueryParamValue(cov)
    if (patternCode == null) return null // don't wrap null
    return new CoverageParam(:codeIdentifier = cov.Pattern.CodeIdentifier,
        :patternCode = patternCode)
  }

  override function getDependentValues(dependencies : String[]) : Map<String, String> {
    return {}
  }


  override function getValueMap(args : String[]) : Map<String, String> {
    if (_cache.Empty) {
      PolicyLinePattern.CoverageCategories
        .orderBy(\ category -> category.Priority).thenBy(\ category -> category.Name)
        .each(\ covCategory -> {
          var categoryName = covCategory.Name
          covCategory.CoveragePatterns
            .orderBy(\ cov -> cov.Priority).thenBy(\ cov -> cov.Name)
            .each(\ cov -> {
              _cache.put(cov.PublicID, DisplayKey.get("Web.Rating.CoverageValueProvider.DisplayLabel", categoryName, cov.Name))
            })
      })
    }
    return _cache
  }


  override property get ArgumentsHelpText() : String {
    return DisplayKey.get("Web.Rating.RateTableDefinition.ValueProvider.HelpText.CoverageValueProvider")
  }

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

}