package gw.rating.flow

uses gw.lang.reflect.TypeSystem
uses gw.rating.flow.util.InScopeUsage
uses gw.rating.flow.util.RatingEntityGraphTraverser
uses java.util.Map
uses gw.api.database.Query
uses java.lang.IllegalStateException
uses java.lang.IllegalArgumentException
uses java.util.List

@ReadOnly
enhancement CalcRoutineParameterSetEnhancement : entity.CalcRoutineParameterSet {

  property get WritableParameterUsages() : Map<CalcRoutineParameter,List<InScopeUsage>>{
    return RatingEntityGraphTraverser.getWritableTargetElements(this)
  }

  static property get ParamSetsReferencedForRoutinesInPromotedBook() : java.util.Set<String> {
    var promotedRateBooksQuery = Query.make(RateBook).compare(RateBook#Status, NotEquals, RateBookStatus.TC_DRAFT)

    var routineDefQuery = Query.make(CalcRoutineDefinition)
    routineDefQuery.join(RateBookCalcRoutine#CalcRoutineDefinition).subselect(RateBookCalcRoutine#RateBook, CompareIn, promotedRateBooksQuery, RateBook#ID)

    var paramSetQuery = Query.make(CalcRoutineParameterSet)
    return (paramSetQuery.subselect(CalcRoutineParameterSet#ID, CompareIn, routineDefQuery, CalcRoutineDefinition#ParameterSet).select().map(\crps -> crps.Code).toSet())
  }

  static property get ParamSetsReferencedInRateTableDefinitions() : java.util.Set<String> {
    var paramSetQuery = Query.make(CalcRoutineParameterSet)
    return paramSetQuery.join(RateTableArgumentSourceSet#CalcRoutineParameterSet).select().map(\crps -> crps.Code).toSet()
  }

  static property get ParamSetsReferencedInRateTableDefinitionsInPromotedBooks() : java.util.Set<String> {
    var promotedRateBooksQuery = Query.make(RateBook).compare(RateBook#Status, NotEquals, RateBookStatus.TC_DRAFT)

    var paramSetQuery = Query.make(CalcRoutineParameterSet)
    .join(RateTableArgumentSourceSet#CalcRoutineParameterSet)
    .join(RateTableArgumentSourceSet#RateTableDefinition)
    .join(RateTable#Definition).subselect(RateTable#RateBook,CompareIn,promotedRateBooksQuery,RateBook#ID)

    return (paramSetQuery.select().map(\crps -> crps.Code).toSet())
  }

  public function validateParamMap(paramNameObjMap : Map<CalcRoutineParamName,Object>) {
    if (this.Parameters.Count > 0 && this.Parameters.Count > 0) {
      var unAccountedForParams = this.Parameters*.Code.toSet().subtract(paramNameObjMap.Keys)
      if (unAccountedForParams.Count > 0) {
        throw new IllegalStateException("The following parameters are needed to execute rate routine: " + 
              unAccountedForParams.map(\p -> p.Code).join(","))
      }
      this.Parameters.each(\param -> {
        var paramObj = paramNameObjMap.get(param.Code)
        if (paramObj == null) {
          return // Allow null targets
        }
        var paramTypeStr = param.ParamType
        var classType = TypeSystem.getByFullNameIfValid(param.ParamType)
        if (classType==null) {
          throw new IllegalStateException("Invalid parameter type: " + param.ParamType)
        }

        var paramObjType = typeof paramObj
        if (!gw.api.util.TypeUtil.isNominallyOrStructurallyAssignable(classType, paramObjType)) {
          throw new IllegalArgumentException("Expected Parameter name: " + param.Code.DisplayName + "(" + param.Code + ")" +
                                             " to be of type: " + paramTypeStr +
                                             " but was type: " + paramObjType.Name)
        }
      })
    }
  }

}