package test.rulez.evaluators;

import org.drools.base.BaseEvaluator;
import org.drools.base.ValueType;
import org.drools.common.InternalWorkingMemory;
import org.drools.rule.VariableRestriction.ObjectVariableContextEntry;
import org.drools.rule.VariableRestriction.VariableContextEntry;
import org.drools.spi.FieldValue;
import org.drools.spi.InternalReadAccessor;
import test.rulez.evaluators.F_StrEvaluatorDefinition.Operations;

public class F_StrEvaluator extends BaseEvaluator {

  private Operations parameter;

  public void setParameterText(String parameterText) {
    this.parameter = Operations.valueOf(parameterText);
  }

  public Operations getParameter() {
    return parameter;
  }

  public F_StrEvaluator(final ValueType type, final boolean isNegated) {
    super(type, isNegated ? F_StrEvaluatorDefinition.NOT_STR_COMPARE : F_StrEvaluatorDefinition.STR_COMPARE);
  }

  @Override
  public boolean evaluate(InternalWorkingMemory workingMemory, InternalReadAccessor extractor, Object object, FieldValue value) {
    final Object objectValue = extractor.getValue(workingMemory, object);
    String objectValueString = (String) objectValue;
    return evaluateAll((String) value.getValue(), objectValueString);
  }

  @Override
  public boolean evaluate(InternalWorkingMemory iwm, InternalReadAccessor ira, Object left, InternalReadAccessor ira1, Object right) {
    return evaluateAll((String) left, (String) right);
  }

  @Override
  public boolean evaluateCachedLeft(InternalWorkingMemory workingMemory, VariableContextEntry context, Object right) {
    final Object valRight = context.extractor.getValue(workingMemory, right);
    return evaluateAll((String) ((ObjectVariableContextEntry) context).left, (String) valRight);
  }

  @Override
  public boolean evaluateCachedRight(InternalWorkingMemory workingMemory, VariableContextEntry context, Object left) {
    final Object varLeft = context.declaration.getExtractor().getValue(workingMemory, left);
    return evaluateAll((String) varLeft, (String) ((ObjectVariableContextEntry) context).right);
  }

  public boolean evaluateAll(String leftString, String rightString) {
    boolean result = ((leftString != null) && (rightString != null));

    if (result) {
      switch (parameter) {
        case startsWith:
          result = this.getOperator().isNegated() ^ (leftString.startsWith(rightString));
          return result;
        case endsWith:
          result = this.getOperator().isNegated() ^ (leftString.endsWith(rightString));
          return result;
      }
    }
    return result;
  }
}