package gw.rating

uses gw.lang.reflect.IType

@SuppressWarnings("unused")
class NoOpLogger implements RateRoutineExecutionLogger{
  final var _first : NoOpTermWrapper as readonly Term
  final var _add : NoOpTermWrapper as readonly Addition
  final var _div : NoOpTermWrapper as readonly Division
  final var _mult : NoOpTermWrapper as readonly Multiplication
  final var _sub : NoOpTermWrapper as readonly Subtraction
  final var _eq : NoOpTermWrapper as readonly EqualTo
  final var _lt : NoOpTermWrapper as readonly LessThan
  final var _gt : NoOpTermWrapper as readonly GreaterThan
  final var _lte : NoOpTermWrapper as readonly LessThanEqual
  final var _gte : NoOpTermWrapper as readonly GreaterThanEqual
  final var _ne : NoOpTermWrapper as readonly NotEqual
  final var _or : NoOpTermWrapper as readonly LogicalOr
  final var _and : NoOpTermWrapper as readonly LogicalAnd
  final var _in : NoOpTermWrapper as readonly TypekeyIn
  final var _ni : NoOpTermWrapper as readonly TypekeyNotIn

  static final var NOOP_FRAME = new NoOpAssignmentFrame()

  static final var NOOP_LOGGER = new NoOpLogger()

  protected construct() {
    var noOpTermWrapper = new NoOpTermWrapper(this)
    _first = noOpTermWrapper
    _add = noOpTermWrapper
    _div = noOpTermWrapper
    _mult = noOpTermWrapper
    _sub = noOpTermWrapper
    _eq = noOpTermWrapper
    _lt = noOpTermWrapper
    _gt = noOpTermWrapper
    _lte = noOpTermWrapper
    _gte = noOpTermWrapper
    _ne = noOpTermWrapper
    _or = noOpTermWrapper
    _and = noOpTermWrapper
    _in = noOpTermWrapper
    _ni = noOpTermWrapper
  }

  static function get() : NoOpLogger {
    return NOOP_LOGGER
  }

  /**
   * Called before rating to acquire any necessary thread-local resources.
   */
  static function beginRating() {
  }

  /**
   * Called after rating to release any thread-local resources. Should be
   * called within a finally block.
   */
  static function endRating() {
  }

  override function begin(book : String, bookEdition : String, routineCode : String, routineVersion : String) {
  }

  override function end() {
  }

  override reified function let<T>(variableName: String, value: T): T {
    return let<T>(variableName, \ -> value)
  }

  override reified function let<T>(variableName : String, code : block() : T ) : T {
    return code()
  }

  override reified function store<T>(variableName : String, code : block(): T) : T {
    return code()
  }

  override reified function retrn<T>(value : T) : T {
    return value
  }

  override reified function retrn<T>(code : block(): T) : T {
    return code()
  }

  override reified function set<T>(objectName : String, obj : Object, propertyName : String, code : block(): T) : T {
    return code()
  }

  override function subr(clazz : IType, functionName : String, code : block()) {
    code()
  }

  override function subr(clazz : IType, functionName : String, type : String, code : block()) {
    code()
  }

  override function method(functionName : String, code : block()) {
    code()
  }

  override function method(objectName : String, object : Object, functionName : String, code : block()) {
    code()
  }

  override function method(objectName : String, object : Object, functionName : String, type : String, code : block()) {
    code()
  }

  override function loop(iterableName : String, iterableTypeName : String, loopVarName : String, loopVarTypeName : String,
                         loopIndexVarName : String, iterableSize : int) {
  }

  override function iteration(iterableName : String, iterableTypeName : String, loopvarName : String, loopvarTypeName : String,
                              loopIndexVarName : String, loopIndexVarValue : int) {
  }

  override function endloop() {
  }

  override function conditionals(code : block()) {
    code()
  }

  override function iff(code : block() : boolean) : boolean {
    return code()
  }

  override function elsif(code : block() : boolean) : boolean {
    return code()
  }

  override function els() {
  }

  override function beginConditional(initialIf : boolean) {
  }

  override function setConditionalResult(value : boolean) {
  }

  override function endConditional(isEndif : boolean) {
  }

  override function note(note : String) {
  }

  override function note(type : String, note : String) {
  }

  override function br() {
  }

  override reified function arg<T>(name : String, code : block(): T) : T {
    return code()
  }

  override reified function arg<T>(name : String, value : T) : T {
    return value
  }

  override reified function argVar<T>(argumentName: String, localVariableName: String, value: T): T {
    return value
  }

  override reified function loggedRateQuery<T>(op : String, rateBook : RateBook, table : String) : NoOpLoggedRateQuery<T> {
    return loggedRateQuery<T>(op, 0, 0, rateBook, table)
  }

  override reified function loggedRateQuery<T>(op : String, leftParens : int, rightParens : int, rateBook : RateBook, table : String) : NoOpLoggedRateQuery<T> {
    return new NoOpLoggedRateQuery<T>(this, op, leftParens, rightParens, rateBook, table)
  }

  override function clear() {
  }

  public function startAssignment(variableName : String, variableDeclaration : boolean) : NoOpAssignmentFrame {
    return NOOP_FRAME
  }

  public function startSet(objectName : String, obj : Object, propertyName : String) : NoOpAssignmentFrame {
    return NOOP_FRAME
  }

  public function startCostDataRounding() : NoOpAssignmentFrame {
    return NOOP_FRAME
  }

  /**
   * @param isInitialIf true if the expression of an if, false if the expression of an if else
   */
  public function startIf(isInitialIf : boolean) : NoOpAssignmentFrame {
    return NOOP_FRAME
  }

  public static final class NoOpAssignmentFrame implements AssignmentFrame {
    override public function finishAssignment<T>(result : T) {
    }

    override public function finish() {
    }
  }

  public static final class NoOpPushFrame implements PushFrame {
    override function pop<T>(returnVal : T) : T {
      return returnVal
    }
  }

  public static final class NoOpVoidFunctionFrame implements VoidFunctionFrame {
    override function finishVFn() {
    }
  }

  public static final class NoOpPushVoidFunctionFrame implements PushVoidFunctionFrame {
    function popVfn() {
    }
  }

  public static final class NoOpOperationFrame implements OperationFrame {
    override function calcValue<T>(value : T) : T {
      return value
    }
  }
}