package gw.rating

uses gw.lang.reflect.IType
uses gw.rating.RateRoutineExecutionLogger.OperationFrame
uses gw.rating.RateRoutineExecutionLogger.VoidFunctionFrame

interface RateRoutineExecutionTermWrapper {
  /**
   * Captures a constant value
   * @param value The value
   * @return the value of the constant
   *
   */
  reified function co<T>(value : T) : T

  /**
   * Captures a constant value along with its surrounding parentheses
   * @param value The constant value
   * @param leftParens the number of parentheses to the left
   * @param rightParens the number of parentheses to the right
   * @return the value of the constant
   *
   */
  reified function co<T>(value : T, leftParens : int, rightParens : int) : T

  /**
   * Captures a variable
   * @param name Variable name
   * @param value Variable value
   * @return the variable value
   */
  reified function vr<T>(name : String, value : T) : T

  /**
   * Captures a variable
   * @param name Variable name
   * @param value Variable value
   * @param type Arbitrary string value; may be useful as a rendering hint
   * @return the variable value
   */
  reified function vr<T>(name : String, type : String, value : T) : T

  /**
   * Captures a variable along with is surrounding parentheses
   * @param name Variable name
   * @param value Variable value
   * @param leftParens the number of parentheses to the left
   * @param rightParens the number of parentheses to the right
   * @return the variable value
   */
  reified function vr<T>(name : String, value : T, leftParens : int, rightParens : int) : T

  /**
   * Captures a variable along with is surrounding parentheses
   * @param name Variable name
   * @param value Variable value
   * @param type Arbitrary string value; may be useful as a rendering hint
   * @param leftParens the number of parentheses to the left
   * @param rightParens the number of parentheses to the right
   * @return the variable value
   */
  reified function vr<T>(name : String, type : String, value : T, leftParens : int, rightParens : int) : T

  /**
   * Captures a variable along with is surrounding parentheses
   * @param name Variable name
   * @param value Variable value
   * @param type Arbitrary string value; may be useful as a rendering hint
   * @param leftParens the number of parentheses to the left
   * @param rightParens the number of parentheses to the right
   * @param hints an array of hints used for rendering
   * @return the variable value
   */
  reified function vr<T>(name : String, type : String, value : T, leftParens : int, rightParens : int, hints : String[]) : T

  /**
   * Captures a value from an object's property getter
   * @param objectName Object name
   * @param object Object
   * @param propertyName Property name
   * @param value Value
   * @return the property value
   *
   */
  reified function get<T>(objectName: String, object: Object, propertyName: String, value: T) : T

  /**
   * Captures a value from an object's property getter
   * @param objectName Object name
   * @param object Object
   * @param propertyName Property name
   * @param type Arbitrary string value; may be useful as a rendering hint
   * @param value Value
   * @return the property value
   *
   */
  reified function get<T>(objectName: String, object: Object, propertyName: String, type: String, value: T) : T

  /**
   * Captures a value from an object's property getter
   * @param objectName Object name
   * @param object Object
   * @param propertyName Property name
   * @param value Value
   * @param leftParens the number of parentheses to the left
   * @param rightParens the number of parentheses to the right
   * @return the property value
   *
   */
  reified function get<T>(objectName: String, object: Object, propertyName: String, value: T, leftParens: int, rightParens: int) : T

  /**
   * Captures a value from an object's property getter
   * @param objectName Object name
   * @param object Object
   * @param propertyName Property name
   * @param type Arbitrary string value; may be useful as a rendering hint
   * @param value Value
   * @param leftParens the number of parentheses to the left
   * @param rightParens the number of parentheses to the right
   * @return the property value
   *
   */
  reified function get<T>(objectName: String, object: Object, propertyName: String, type: String, value: T, leftParens: int, rightParens: int) : T

  /**
   * Captures a value from an object's property getter
   * @param objectName Object name
   * @param object Object
   * @param propertyName Property name
   * @param type Arbitrary string value; may be useful as a rendering hint
   * @param value Value
   * @param leftParens the number of parentheses to the left
   * @param rightParens the number of parentheses to the right
   * @param hints an array of hints used for rendering
   * @return the property value
   *
   */
  reified function get<T>(objectName : String, object : Object, propertyName : String, type : String, value : T,
                          leftParens : int, rightParens : int, hints : String[]) : T

  /**
   * Captures a function call
   * @param clazz Class containing the function
   * @param functionName Function name
   * @param code the function call itself
   * @return the return value of the function call
   */
  reified function fn<T>(clazz : IType, functionName : String, code : block() : T) : T

  /**
   * Captures a function call along with a specified type
   * @param clazz Class containing the function
   * @param functionName Function name
   * @param type Arbitrary string value; may be useful as a rendering hint - ie "Rounding"
   * @return the return value of the function call
   */
  reified function fn<T>(clazz : IType, functionName : String, type : String, code : block() : T) : T

  /**
   * Captures a function call along with its surrounding parentheses
   * @param clazz The class containing the function
   * @param functionName Function name
   * @param code the function call itself
   * @param leftParens the number of parentheses to the left
   * @param rightParens the number of parentheses to the right
   * @return the return value of the function call
   */
  reified function fn<T>(clazz : IType, functionName : String, code : block() : T, leftParens : int, rightParens : int) : T

  /**
   * Captures a function call along with its surrounding parentheses
   * @param clazz The class containing the function
   * @param functionName Function name
   * @param type Arbitrary string value; may be useful as a rendering hint
   * @param code the function call itself
   * @param leftParens the number of parentheses to the left
   * @param rightParens the number of parentheses to the right
   * @return the return value of the function call
   */
  reified function fn<T>(clazz : IType, functionName : String, type : String, code : block() : T, leftParens : int, rightParens : int) : T

  /**
   * Captures a function call along with its surrounding parentheses
   * @param clazz The class containing the function
   * @param functionName Function name
   * @param type Arbitrary string value; may be useful as a rendering hint
   * @param code the function call itself
   * @param leftParens the number of parentheses to the left
   * @param rightParens the number of parentheses to the right
   * @param hints an array of hints used for rendering
   * @return the return value of the function call
   */
  reified function fn<T>(clazz : IType, functionName : String, type : String, code : block() : T,
                         leftParens : int, rightParens : int, hints : String[]) : T

  /**
   * Captures a function call on an object
   * @param objectName the object's variable name
   * @param object The object on which the function is invoked
   * @param functionName Function name
   * @param code the function call itself
   * @return the return value of the function call
   */
  reified function fn<T>(objectName : String, object : Object, functionName : String, code : block() : T) : T

  /**
   * Captures a function call on an object along with its surrounding parentheses
   * @param objectName the object's variable name
   * @param object The object on which the function is invoked
   * @param functionName Function name
   * @param type Arbitrary string value; may be useful as a rendering hint
   * @param code the function call itself
   * @param leftParens the number of parentheses to the left
   * @param rightParens the number of parentheses to the right
   * @return the return value of the function call
   */
  reified function fn<T>(objectName : String, object : Object, functionName : String, type : String, code : block() : T,
                         leftParens : int, rightParens : int) : T

  /**
   * Captures a function call on an object along with its surrounding parentheses
   * @param objectName the object's variable name
   * @param object The object on which the function is invoked
   * @param functionName Function name
   * @param type Arbitrary string value; may be useful as a rendering hint
   * @param code the function call itself
   * @param leftParens the number of parentheses to the left
   * @param rightParens the number of parentheses to the right
   * @param hints an array of hints used for rendering
   * @return the return value of the function call
   */
  reified function fn<T>(objectName : String, object : Object, functionName : String, type : String, code : block() : T,
                         leftParens : int, rightParens : int, hints : String[]) : T

  /**
   * Captures a function call (without executing the code for that call)
   *
   * Note - must be paired with {@link gw.rating.worksheet.WorksheetTermWrapper.WorksheetLoggerOperationFrame#calcValue(Object)}
   * e.g.
   *  <pre>f.startFn(gw.lob.pa.rating.PARatingTestFunctions, "getFirstCoverageForFirstVehicle").calcValue(_gw_lob_pa_rating_PARatingTestFunctions.getFirstCoverageForFirstVehicle(_log.argVar("line", "policyline", _policyline)))</pre>
   * @param clazz Class containing the function
   * @param functionName Function name
   * @return the return value of the function call
   */
  reified function startFn<T>(clazz : IType, functionName : String, type: String = null, objectName: String = null,
                              object: T = null, hints: String[] = {}) : OperationFrame

  function startArg(name: String): OperationFrame

  function startVfn(clazz : IType, functionName : String) : VoidFunctionFrame

  /**
   * Captures a void function call
   * @param clazz Class containing the function
   * @param functionName Function name
   * @param code the function call itself
   */
  @SuppressWarnings("unused")
  function vfn(clazz : IType, functionName : String, code : block() : void) : void

  /**
   * Captures a chained function call, such as obj.withParam().withParam()
   *
   * @param name of the function call
   * @param parent the value of the preceding function call
   * @param code the function call
   * @return the return value of the function call
   *
   */
  reified function chain<T,V>(name : String, parent : block() : V, code : block(p : V) : T) : T

  /**
   * Captures a logical negation, such as NOT true
   *
   * @param the expression being negated
   * @return the return value of the negated expression
   *
   */
  reified function no<T>(code : block() : T) : T

  /**
   * Captures a logical negation, such as NOT true along with its surrounding parentheses
   *
   * @param the expression being negated
   * @param leftParens the number of parentheses to the left
   * @param rightParens the number of parentheses to the right
   * @return the return value of the negated expression
   *
   */
  reified function no<T>(code : block() : T, leftParens : int, rightParens : int) : T

  /** Captures an object instantiated with the new operator
   *
   * @param code
   * @return new object
   */
  reified function nnew<T>(code : block() : T) : T

  /** Captures an object instantiated with the new operator
   *
   * @param code
   * @param leftParens the number of parentheses to the left
   * @param rightParens the number of parentheses to the right
   * @return the new object
   *
   */
  reified function nnew<T>(code : block() : T, leftParens : int, rightParens : int) : T

  /** Create a logged rate query
   *
   * @param book Ratebook
   * @param tableCode Table code
   * @return the logged rate query
   */
  reified function query<T>(book : RateBook, tableCode : String) : RateRoutineExecutionLoggedRateQuery<T>

  /** Create a logged rate query
   *
   * @param book Ratebook
   * @param tableCode Table code
   * @param leftParens Number of left parenthesis
   * @param rightParens Number of right parenthesis
   * @return the logged rate query
   */
  reified function query<T>(book : RateBook, tableCode : String, leftParens : int, rightParens : int) : RateRoutineExecutionLoggedRateQuery<T>
}