package gw.rating.rtm.valueprovider

uses gw.api.locale.DisplayKey
uses gw.api.productmodel.CovTermPattern
uses gw.api.productmodel.CoveragePattern
uses gw.api.productmodel.PolicyLinePattern
uses gw.api.productmodel.PolicyLinePatternLookup
uses gw.validation.PCValidationResult

uses java.util.ArrayList
uses java.util.List

class CustomValueProviderData {
  static var _toStrings: Map<ValueProvider, block(RateTableColumn, List<Argument>): String> =
      {ValueProvider.TC_COVTERMOPTIONVALUEPROVIDER -> \col, args -> covTermOptionVPString(col, args)}
  final static var _toStringsReverse: Map<ValueProvider, block(RateTableColumn, List<Argument>): String> =
      {ValueProvider.TC_COVTERMOPTIONVALUEPROVIDER -> \col, args -> reverseCovTermOptionVPString(col, args)}

  var _columnDef : RateTableColumn as readonly ColumnDef
  var _className : ValueProvider as ClassName
  var _args : List<Argument> as Arguments
  final static var _prefix : String as readonly CustomValueProviderPrefix = "gw.rating.rtm.valueprovider."
  final static var _separator : String = ","

  construct(colDef : RateTableColumn) {
    _columnDef = colDef
    var valueProviderString = _columnDef.ValueProvider
    if (valueProviderString != null and valueProviderString.NotBlank) {
      var parser = Parser.parse(valueProviderString)
      if (parser.ClassName != null and parser.ClassName.NotBlank) {
        var keyValue = parser.ClassName.substring(_prefix.length)
        _className = ValueProvider.get(keyValue)
      }
      _args = parser.Arguments.map(\ s -> new Argument(s == "null" ? null : s)).toList()
    } else {
      _className = null
      _args = new ArrayList<Argument>()
    }
  }

  function processRateTableColumnOnExit(result: PCValidationResult) {
    validateValueProvider(_toStrings, result)
  }

  function processRateTableColumnOnEnter(result: PCValidationResult) {
    validateValueProvider(_toStringsReverse, result)
  }

  private function validateValueProvider(
      toStrings: Map<ValueProvider, block(RateTableColumn, List<Argument>): String>,
      result: PCValidationResult) {
    try {
      var toStr = Optional
          .ofNullable(toStrings[_className])
          .orElse(\col, args -> defaultValueProviderString())
      var vpStr = toStr(_columnDef, _args)
      _columnDef.ValueProvider = vpStr
    } catch (e: Exception) {
      result.addError(_columnDef, ValidationLevel.TC_DEFAULT, e.Message)
    }
  }

  function createValueProviderString() {
    _columnDef.ValueProvider = defaultValueProviderString()
  }

  private static function valueProviderString(vp: ValueProvider, args: List<String>): String {
    return _prefix + vp.Code + (args.Empty ? "" : "(${args.join(_separator)})")
  }

  private function defaultValueProviderString(): String {
    return _className == null ? null : valueProviderString(_className, _args.map(\a -> a.Name))
  }

  private static function covTermOptionVPString(col: RateTableColumn, args: List<Argument>): String {
    return genericCovTermOptionVPString(
        col,
        args,
        \plPattern, id -> plPattern.getCoveragePatternByCodeIdentifier(id),
        \cov, id -> cov.CovTerms.firstWhere(\t -> t.CodeIdentifier == id),
        \cov, covTerm -> {return {cov.PublicID, covTerm.PublicID}})
  }

  private static function reverseCovTermOptionVPString(col: RateTableColumn, args: List<Argument>): String {
    return genericCovTermOptionVPString(
        col,
        args,
        \plPattern, id -> plPattern.getCoveragePatternByPublicId(id),
        \cov, id -> cov.CovTerms.firstWhere(\t -> t.PublicID == id),
        \cov, covTerm -> {return {cov.CodeIdentifier, covTerm.CodeIdentifier}})
  }

  private static function genericCovTermOptionVPString(
      col: RateTableColumn,
      args: List<Argument>,
      covGetter(PolicyLinePattern, String): CoveragePattern,
      covTermGetter(CoveragePattern, String): CovTermPattern,
      toStr(CoveragePattern, CovTermPattern): List<String>): String {
    if (args.Count == 0) {
      return valueProviderString(ValueProvider.TC_COVTERMOPTIONVALUEPROVIDER, {})
    }
    if (args.Count != 2) {
      throw new IllegalArgumentException(DisplayKey.get("Validation.Rating.RateTableDefinition.NumArguments", ValueProvider.TC_COVTERMOPTIONVALUEPROVIDER.DisplayName))
    }
    var covId = args[0].Name
    var covTermId = args[1].Name
    var plPattern = PolicyLinePatternLookup.getByPublicID(col.Definition.PolicyLine)
    var coverage = covGetter(plPattern, covId)
    if (coverage == null) {
      throw new IllegalArgumentException(DisplayKey.get("Validation.Rating.RateTableDefinition.CovNotFound", covId, plPattern))
    }
    var covTerm = covTermGetter(coverage, covTermId)
    if (covTerm == null) {
      throw new IllegalArgumentException(DisplayKey.get("Validation.Rating.RateTableDefinition.CovTermNotFound", covTermId, coverage))
    }
    return valueProviderString(ValueProvider.TC_COVTERMOPTIONVALUEPROVIDER, toStr(coverage, covTerm))
  }

  
  function clearArguments() { 
      _args.clear()
  }
  
  function addNewArgument() : Argument {
    var newArg = new Argument("")
    Arguments.add(newArg)
    return newArg
  }

  function validateTypelistArguments() : String {
    if (this.SingleArgument.Empty) {
      return DisplayKey.get("Web.Rating.Errors.TypeListProviderMustHaveArguments", _columnDef.ColumnLabel)
    }
    return null
  }

  property get SingleArgument(): String {
      if (Arguments.Empty) 
        return ""
      else return Arguments.single().Name
  }
      
  property set SingleArgument(str: String){
      Arguments.clear()
      Arguments.add(new Argument(str))
  }

  class Argument {
    public var _name : String as Name

    construct(argName : String) {
      _name = argName
    }
  }

}