/*******************************************************************************
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements. See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership. The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License. You may obtain a copy of the License at
 * 
 * http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied. See the License for the
 * specific language governing permissions and limitations
 * under the License.
 ******************************************************************************/
package org.apache.olingo.odata2.core.uri.expression;

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.apache.olingo.odata2.api.edm.EdmComplexType;
import org.apache.olingo.odata2.api.edm.EdmEntityType;
import org.apache.olingo.odata2.api.edm.EdmException;
import org.apache.olingo.odata2.api.edm.EdmMultiplicity;
import org.apache.olingo.odata2.api.edm.EdmSimpleType;
import org.apache.olingo.odata2.api.edm.EdmSimpleTypeKind;
import org.apache.olingo.odata2.api.edm.EdmStructuralType;
import org.apache.olingo.odata2.api.edm.EdmType;
import org.apache.olingo.odata2.api.edm.EdmTypeKind;
import org.apache.olingo.odata2.api.edm.EdmTyped;
import org.apache.olingo.odata2.api.uri.expression.BinaryExpression;
import org.apache.olingo.odata2.api.uri.expression.BinaryOperator;
import org.apache.olingo.odata2.api.uri.expression.CommonExpression;
import org.apache.olingo.odata2.api.uri.expression.ExpressionKind;
import org.apache.olingo.odata2.api.uri.expression.ExpressionParserException;
import org.apache.olingo.odata2.api.uri.expression.FilterExpression;
import org.apache.olingo.odata2.api.uri.expression.LiteralExpression;
import org.apache.olingo.odata2.api.uri.expression.MethodExpression;
import org.apache.olingo.odata2.api.uri.expression.MethodOperator;
import org.apache.olingo.odata2.api.uri.expression.UnaryExpression;
import org.apache.olingo.odata2.api.uri.expression.UnaryOperator;
import org.apache.olingo.odata2.core.edm.EdmBoolean;
import org.apache.olingo.odata2.core.edm.EdmSimpleTypeFacadeImpl;

/**
 *  
 */
public class FilterParserImpl implements FilterParser {
  /* do the static initialization */
  protected static Map<String, InfoBinaryOperator> availableBinaryOperators;
  protected static Map<String, InfoMethod> availableMethods;
  protected static Map<String, InfoUnaryOperator> availableUnaryOperators;

  static {
    initAvailTables();
  }

  /* instance attributes */
  protected EdmEntityType resourceEntityType = null;
  protected TokenList tokenList = null;
  protected String curExpression;
  protected String originalFilterString = "";
  protected String decodedFilterString  = "";
  private boolean strictFilter = true;


  /**
   * Creates a new FilterParser implementation
   * @param resourceEntityType EntityType of the resource on which the filter is applied
   */
  public FilterParserImpl(final EdmEntityType resourceEntityType) {
    this.resourceEntityType = resourceEntityType;
  }

  /**
   * Creates a new FilterParser implementation
   * @param resourceEntityType EntityType of the resource on which the filter is applied
   * @param strictFilter boolean check to decide weather to validate filter
   */
  public FilterParserImpl(final EdmEntityType resourceEntityType, boolean strictFilter) {
    this.resourceEntityType = resourceEntityType;
    this.strictFilter = strictFilter;
  }

  /**
   * Creates a new FilterParser implementation
   * @param resourceEntityType EntityType of the resource on which the filter is applied
   * @param strictFilter boolean check to decide weather to validate filter
   * @param originalFilterString String original filter string prior to decoding
   */
  public FilterParserImpl(final EdmEntityType resourceEntityType, boolean strictFilter,
                          String originalFilterString) {
    this.resourceEntityType = resourceEntityType;
    this.strictFilter = strictFilter;
    this.originalFilterString = originalFilterString;
  }

  @Override
  public FilterExpression parseFilterString(final String filterExpression) throws ExpressionParserException,
      ExpressionParserInternalError {
    return parseFilterString(filterExpression, false);
  }

  public FilterExpression parseFilterString(final String filterExpression, final boolean allowOnlyBinary)
      throws ExpressionParserException, ExpressionParserInternalError {
    CommonExpression node = null;
    curExpression = filterExpression;
    decodedFilterString = filterExpression;
    try {
      // Throws TokenizerException and FilterParserException. FilterParserException is caught somewhere above
      tokenList = new Tokenizer(filterExpression).tokenize();
      if (!tokenList.hasTokens()) {
        return new FilterExpressionImpl(filterExpression);
      }
    } catch (TokenizerException tokenizerException) {
      // Tested with TestParserExceptions.TestPMparseFilterString
      throw FilterParserExceptionImpl.createERROR_IN_TOKENIZER(tokenizerException, curExpression);
    }

    try {
      CommonExpression nodeLeft = readElement(null);
      node = readElements(nodeLeft, 0);
    } catch (ExpressionParserException filterParserException) {
      // Add empty filterTree to Exception
      // Tested for original throw point
      filterParserException.setFilterTree(new FilterExpressionImpl(filterExpression));
      throw filterParserException;
    }

    // Post check
    if (tokenList.tokenCount() > tokenList.currentToken) // this indicates that not all tokens have been read
    {
      // Tested with TestParserExceptions.TestPMparseFilterString
      throw FilterParserExceptionImpl.createINVALID_TRAILING_TOKEN_DETECTED_AFTER_PARSING(tokenList
          .elementAt(tokenList.currentToken), filterExpression);
    }

    // Create and return filterExpression node
    if ((allowOnlyBinary == true) && (node.getEdmType() != null)
        && (node.getEdmType() != EdmSimpleTypeKind.Boolean.getEdmSimpleTypeInstance())) {
      // Tested with TestParserExceptions.testAdditionalStuff CASE 9
      throw FilterParserExceptionImpl.createTYPE_EXPECTED_AT(EdmBoolean.getInstance(), node.getEdmType(), 1,
          curExpression);
    }
    if (filterExpression.equals(decodedFilterString)) {
        return new FilterExpressionImpl(filterExpression, node);
    } else {
        return new FilterExpressionImpl(decodedFilterString, node);
    } 
  }

  protected CommonExpression readElements(final CommonExpression leftExpression, final int priority)
      throws ExpressionParserException, ExpressionParserInternalError {
    CommonExpression leftNode = leftExpression;
    CommonExpression rightNode;
    BinaryExpression binaryNode;

    ActualBinaryOperator operator = readBinaryOperator();
    ActualBinaryOperator nextOperator;

    while ((operator != null) && (operator.getOP().getPriority() >= priority)) {
      tokenList.next(); // eat the operator
      rightNode = readElement(leftNode, operator); // throws FilterParserException, FilterParserInternalError
      if (rightNode == null) {
        // Tested with TestParserExceptions.testAdditionalStuff CASE 10
        throw FilterParserExceptionImpl.createEXPRESSION_EXPECTED_AFTER_POS(operator.getToken().getPosition()
            + operator.getToken().getUriLiteral().length(), curExpression);
      }
      nextOperator = readBinaryOperator();

      // It must be "while" because for example in "Filter=a or c eq d and e eq f"
      // after reading the "eq" operator the "and" operator must be consumed too. This is due to the fact that "and" has
      // a higher priority than "or"
      while ((nextOperator != null) && (nextOperator.getOP().getPriority() > operator.getOP().getPriority())) {
        // recurse until the a binary operator with a lower priority is detected
        rightNode = readElements(rightNode, nextOperator.getOP().getPriority());
        nextOperator = readBinaryOperator();
      }

      // Although the member operator is also a binary operator, there is some special handling in the filterTree
      if (operator.getOP().getOperator() == BinaryOperator.PROPERTY_ACCESS) {
        binaryNode = new MemberExpressionImpl(leftNode, rightNode);
      } else {
        binaryNode = new BinaryExpressionImpl(operator.getOP(), leftNode, rightNode, operator.getToken());
      }

      try {
        validateBinaryOperatorTypes(binaryNode);
      } catch (ExpressionParserException expressionException) {
        // Extend the error information
        // Tested for original throw point
        expressionException.setFilterTree(binaryNode);
        throw expressionException;
      }

      leftNode = binaryNode;
      operator = readBinaryOperator();
    }

    // Add special handling for expressions like $filter=notsupportedfunction('a')
    // If this special handling is not in place the error text would be
    // -->Invalid token "(" detected after parsing at position 21 in "notsupportedfunction('a')".
    // with this special handling we ensure that the error text would be

    Token token = tokenList.lookToken();
    if (token != null) {
      if ((leftNode.getKind() == ExpressionKind.PROPERTY) && (tokenList.lookToken().getKind() == TokenKind.OPENPAREN)) {
        // Tested with TestParserExceptions.testAdditionalStuff CASE 2
        throw FilterParserExceptionImpl.createINVALID_METHOD_CALL(leftNode, tokenList.lookPrevToken(), curExpression);
      }
    }

    return leftNode;
  }

  /**
   * Reads the content between parenthesis. Its is expected that the current token is of kind
   * {@link TokenKind#OPENPAREN} because it MUST be check in the calling method ( when read the method name and the '('
   * is read).
   * @return An expression which reflects the content within the parenthesis
   * @throws ExpressionParserException
   * While reading the elements in the parenthesis an error occurred
   * @throws TokenizerMessage
   * The next token did not match the expected token
   */
  protected CommonExpression readParenthesis() throws ExpressionParserException, ExpressionParserInternalError {
    // The existing of a '(' is verified BEFORE this method is called --> so it's a internal error
    Token openParenthesis = tokenList.expectToken(TokenKind.OPENPAREN, true);

    CommonExpression firstExpression = readElement(null);
    CommonExpression parenthesisExpression = readElements(firstExpression, 0);

    // check for ')'
    try {
      tokenList.expectToken(TokenKind.CLOSEPAREN); // TokenizerMessage
    } catch (TokenizerExpectError e) {
      // Internal parsing error, even if there are no more token (then there should be a different exception).
      // Tested with TestParserExceptions.TestPMreadParenthesis
      throw FilterParserExceptionImpl.createMISSING_CLOSING_PARENTHESIS(openParenthesis.getPosition(), curExpression,
          e);
    }
    return parenthesisExpression;
  }

  /**
   * Read the parameters of a method expression
   * @param methodInfo
   * Signature information about the method whose parameters should be read
   * @param methodExpression
   * Method expression to which the read parameters are added
   * @return
   * The method expression input parameter
   * @throws ExpressionParserException
   * @throws ExpressionParserInternalError
   * @throws TokenizerExpectError
   * The next token did not match the expected token
   */
  protected MethodExpression readParameters(final InfoMethod methodInfo, final MethodExpressionImpl methodExpression,
      final Token methodToken) throws ExpressionParserException, ExpressionParserInternalError {
    CommonExpression expression;
    boolean expectAnotherExpression = false;
    boolean readComma = true;

    // The existing of a '(' is verified BEFORE this method is called --> so it's a internal error
    Token openParenthesis = tokenList.expectToken(TokenKind.OPENPAREN, true); // throws FilterParserInternalError

    Token token = tokenList.lookToken();
    if (token == null) {
      // Tested with TestParserExceptions.TestPMreadParameters CASE 1 e.g. "$filter=concat("
      throw FilterParserExceptionImpl.createEXPRESSION_EXPECTED_AFTER_POS(openParenthesis, curExpression);
    }

    while (token.getKind() != TokenKind.CLOSEPAREN) {
      if (readComma == false) {
        // Tested with TestParserExceptions.TestPMreadParameters CASE 12 e.g. "$filter=concat('a' 'b')"
        throw FilterParserExceptionImpl.createCOMMA_OR_CLOSING_PARENTHESIS_EXPECTED_AFTER_POS(tokenList
            .lookPrevToken(), curExpression);
      }
      expression = readElement(null);
      if (expression != null) {
        expression = readElements(expression, 0);
      }

      if ((expression == null) && (expectAnotherExpression == true)) {
        // Tested with TestParserExceptions.TestPMreadParameters CASE 4 e.g. "$filter=concat(,"
        throw FilterParserExceptionImpl.createEXPRESSION_EXPECTED_AFTER_POS(token, curExpression);
      } else if (expression != null) {// parameter list may be empty
        methodExpression.appendParameter(expression);
      }

      token = tokenList.lookToken();
      if (token == null) {
        // Tested with TestParserExceptions.TestPMreadParameters CASE 2 e.g. "$filter=concat(123"
        throw FilterParserExceptionImpl.createCOMMA_OR_CLOSING_PARENTHESIS_EXPECTED_AFTER_POS(tokenList
            .lookPrevToken(), curExpression);
      }

      if (token.getKind() == TokenKind.COMMA) {
        expectAnotherExpression = true;
        if (expression == null) {
          // Tested with TestParserExceptions.TestPMreadParameters CASE 3 e.g. "$filter=concat(,"
          throw FilterParserExceptionImpl.createEXPRESSION_EXPECTED_AT_POS(token, curExpression);
        }

        tokenList.expectToken(",", true);
        readComma = true;
      } else {
        readComma = false;
      }
    }

    // because the while loop above only exits if a ')' has been found it is an
    // internal error if there is not ')'
    tokenList.expectToken(TokenKind.CLOSEPAREN, true);

    // ---check parameter count
    int count = methodExpression.getParameters().size();
    if ((methodInfo.getMinParameter() > -1) && (count < methodInfo.getMinParameter())) {
      // Tested with TestParserExceptions.TestPMreadParameters CASE 12
      throw FilterParserExceptionImpl.createMETHOD_WRONG_ARG_COUNT(methodExpression, methodToken, curExpression);
    }

    if ((methodInfo.getMaxParameter() > -1) && (count > methodInfo.getMaxParameter())) {
      // Tested with TestParserExceptions.TestPMreadParameters CASE 15
      throw FilterParserExceptionImpl.createMETHOD_WRONG_ARG_COUNT(methodExpression, methodToken, curExpression);
    }

    return methodExpression;
  }

  protected CommonExpression readElement(final CommonExpression leftExpression) throws ExpressionParserException,
      ExpressionParserInternalError {
    return readElement(leftExpression, null);
  }

  /**
   * Reads: Unary operators, Methods, Properties, ...
   * but not binary operators which are handelt in {@link #readElements(CommonExpression, int)}
   * @param leftExpression
   * Used while parsing properties. In this case ( e.g. parsing "a/b") the property "a" ( as leftExpression of "/") is
   * relevant
   * to verify whether the property "b" exists inside the edm
   * @return a CommonExpression
   * @throws ExpressionParserException
   * @throws ExpressionParserInternalError
   * @throws TokenizerMessage
   */
  protected CommonExpression
      readElement(final CommonExpression leftExpression, final ActualBinaryOperator leftOperator)
          throws ExpressionParserException, ExpressionParserInternalError {
    CommonExpression node = null;
    Token token;
    Token lookToken;
    lookToken = tokenList.lookToken();
    if (lookToken == null) {
      return null;
    }

    switch (lookToken.getKind()) {
    case OPENPAREN:
      node = readParenthesis();
      return node;
    case CLOSEPAREN: // ')' finishes a parenthesis (it is no extra token)" +
    case COMMA: // . " ','  is a separator for function parameters (it is no extra token)" +
      return null;
    default:
      // continue
    }

    // -->Check if the token is a unary operator
    InfoUnaryOperator unaryOperator = isUnaryOperator(lookToken);
    if (unaryOperator != null) {
      return readUnaryoperator(lookToken, unaryOperator);
    }

    // ---expect the look ahead token
    token = tokenList.expectToken(lookToken.getUriLiteral(), true);
    lookToken = tokenList.lookToken();

    // -->Check if the token is a method
    // To avoid name clashes between method names and property names we accept here only method names if a "(" follows.
    // Hence the parser accepts a property named "concat"
    InfoMethod methodOperator = isMethod(token, lookToken);
    if (methodOperator != null) {
      return readMethod(token, methodOperator);
    }

    // -->Check if token is a terminal
    // is a terminal e.g. a Value like an EDM.String 'hugo' or 125L or 1.25D"
    if (token.getKind() == TokenKind.SIMPLE_TYPE) {
    	 LiteralExpression literal = new LiteralExpressionImpl(
       		  getEncodedUriLiteral(token.getUriLiteral(),token.getPosition()), token.getJavaLiteral());
      return literal;
    }

    // -->Check if token is a property, e.g. "name" or "address"
    if (token.getKind() == TokenKind.LITERAL) {
      PropertyExpressionImpl property = new PropertyExpressionImpl(token.getUriLiteral(), token.getJavaLiteral());
      validateEdmProperty(leftExpression, property, token, leftOperator);
      return property;
    }

    // not Tested, should not occur
    throw ExpressionParserInternalError.createCOMMON();
  }

  protected CommonExpression readUnaryoperator(final Token lookToken, final InfoUnaryOperator unaryOperator)
      throws ExpressionParserException, ExpressionParserInternalError {
    tokenList.expectToken(lookToken.getUriLiteral(), true);

    CommonExpression operand = readElement(null);
    UnaryExpression unaryExpression = new UnaryExpressionImpl(unaryOperator, operand);
    validateUnaryOperatorTypes(unaryExpression); // throws ExpressionInvalidOperatorTypeException

    return unaryExpression;
  }

  protected CommonExpression readMethod(final Token token, final InfoMethod methodOperator)
      throws ExpressionParserException, ExpressionParserInternalError {
    MethodExpressionImpl method = new MethodExpressionImpl(methodOperator);

    readParameters(methodOperator, method, token);
    validateMethodTypes(method, token); // throws ExpressionInvalidOperatorTypeException

    return method;
  }

  protected ActualBinaryOperator readBinaryOperator() {
    InfoBinaryOperator operator = null;
    Token token = tokenList.lookToken();
    if (token == null) {
      return null;
    }
    if ((token.getKind() == TokenKind.SYMBOL) && ("/".equals(token.getUriLiteral()))) {
      operator = availableBinaryOperators.get(token.getUriLiteral());
    } else if (token.getKind() == TokenKind.LITERAL) {
      operator = availableBinaryOperators.get(token.getUriLiteral());
    }

    if (operator == null) {
      return null;
    }

    return new ActualBinaryOperator(operator, token);
  }

  /**
   * Check if a token is a UnaryOperator ( e.g. "not" or "-" )
   * 
   * @param token Token to be checked
   * 
   * @return
   * <li>An instance of {@link InfoUnaryOperator} containing information about the specific unary operator</li>
   * <li><code>null</code> if the token is not an unary operator</li>
   */
  protected InfoUnaryOperator isUnaryOperator(final Token token) {
    if ((token.getKind() == TokenKind.LITERAL) || (token.getKind() == TokenKind.SYMBOL)) {
      InfoUnaryOperator operator = availableUnaryOperators.get(token.getUriLiteral());
      return operator;
    }
    return null;
  }

  protected InfoMethod isMethod(final Token token, final Token lookToken) {
    if ((lookToken != null) && (lookToken.getKind() == TokenKind.OPENPAREN)) {
      return availableMethods.get(token.getUriLiteral());
    }
    return null;
  }

  protected void validateEdmProperty(final CommonExpression leftExpression, final PropertyExpressionImpl property,
      final Token propertyToken, final ActualBinaryOperator actBinOp) throws ExpressionParserException,
      ExpressionParserInternalError {

    // Exit if no edm provided
    if (resourceEntityType == null) {
      return;
    }

    if (leftExpression == null) {
      // e.g. "$filter=city eq 'Hong Kong'" --> "city" is checked against the resource entity type of the last URL
      // segment
      validateEdmPropertyOfStructuredType(resourceEntityType, property, propertyToken);
      return;
    }
    // e.g. "$filter='Hong Kong' eq address/city" --> city is "checked" against the type of the property "address".
    // "address" itself must be a (navigation)property of the resource entity type of the last URL segment AND
    // "address" must have a structural edm type
    EdmType parentType = leftExpression.getEdmType(); // parentType point now to the type of property "address"

    if ((actBinOp != null) && (actBinOp.operator.getOperator() != BinaryOperator.PROPERTY_ACCESS)) {
      validateEdmPropertyOfStructuredType(resourceEntityType, property, propertyToken);
      return;
    } else {
      if ((leftExpression.getKind() != ExpressionKind.PROPERTY) &&
          (leftExpression.getKind() != ExpressionKind.MEMBER)) {
        if (actBinOp != null) {
          // Tested with TestParserExceptions.TestPMvalidateEdmProperty CASE 6
          throw FilterParserExceptionImpl.createLEFT_SIDE_NOT_A_PROPERTY(actBinOp.token, curExpression);
        } else {
          // not Tested, should not occur
          throw ExpressionParserInternalError.createCOMMON();
        }

      }
    }

    if (parentType instanceof EdmEntityType) {
      // e.g. "$filter='Hong Kong' eq navigationProp/city" --> "navigationProp" is a navigation property with a entity
      // type
      validateEdmPropertyOfStructuredType((EdmStructuralType) parentType, property, propertyToken);
    } else if (parentType instanceof EdmComplexType) {
      // e.g. "$filter='Hong Kong' eq address/city" --> "address" is a property with a complex type
      validateEdmPropertyOfStructuredType((EdmStructuralType) parentType, property, propertyToken);
    } else {
      // e.g. "$filter='Hong Kong' eq name/city" --> "name is of type String"
      // Tested with TestParserExceptions.TestPMvalidateEdmProperty CASE 5
      throw FilterParserExceptionImpl.createLEFT_SIDE_NOT_STRUCTURAL_TYPE(parentType, property, propertyToken,
          curExpression);
    }

    return;
  }

  protected void validateEdmPropertyOfStructuredType(final EdmStructuralType parentType,
      final PropertyExpressionImpl property, final Token propertyToken) throws ExpressionParserException,
      ExpressionParserInternalError {
    try {
      String propertyName = property.getUriLiteral();
      EdmTyped edmProperty = parentType.getProperty(propertyName);

      if (edmProperty != null) {
        property.setEdmProperty(edmProperty);
        property.setEdmType(edmProperty.getType());
        if(isLastFilterElement(propertyName)) {
          if (edmProperty.getMultiplicity() == EdmMultiplicity.MANY && strictFilter) {
            throw new ExpressionParserException(
                ExpressionParserException.INVALID_MULTIPLICITY.create()
                    .addContent(propertyName)
                    .addContent(propertyToken.getPosition() + 1));
          }
        }
      } else {
        // Tested with TestParserExceptions.TestPMvalidateEdmProperty CASE 3
        throw FilterParserExceptionImpl.createPROPERTY_NAME_NOT_FOUND_IN_TYPE(parentType, property, propertyToken,
            curExpression);
      }

    } catch (EdmException e) {
      // not Tested, should not occur
      throw ExpressionParserInternalError.createERROR_ACCESSING_EDM(e);
    }
  }

  /**
   * Check if the property name is the last or only element of the filter
   * @param propertyName name of the property
   * @return <code>true</code> if this is the last or only otherwise <code>false</code>
   */
  private boolean isLastFilterElement(String propertyName) {
    return curExpression.contains(propertyName + " ");
  }

  protected void validateUnaryOperatorTypes(final UnaryExpression unaryExpression)
      throws ExpressionParserInternalError {
    InfoUnaryOperator unOpt = availableUnaryOperators.get(unaryExpression.getOperator().toUriLiteral());
    EdmType operandType = unaryExpression.getOperand().getEdmType();

    if ((operandType == null) && (resourceEntityType == null)) {
      return;
    }

    List<EdmType> actualParameterTypes = new ArrayList<EdmType>();
    actualParameterTypes.add(operandType);

    ParameterSet parameterSet = unOpt.validateParameterSet(actualParameterTypes);
    if (parameterSet != null) {
      unaryExpression.setEdmType(parameterSet.getReturnType());
    }
  }

  protected void validateBinaryOperatorTypes(final BinaryExpression binaryExpression) throws ExpressionParserException,
      ExpressionParserInternalError {
    InfoBinaryOperator binOpt = availableBinaryOperators.get(binaryExpression.getOperator().toUriLiteral());

    List<EdmType> actualParameterTypes = new ArrayList<EdmType>();
    final EdmType leftType = binaryExpression.getLeftOperand().getEdmType();
    if (leftType == null && resourceEntityType == null) {
      return;
    }
    actualParameterTypes.add(leftType);

    final EdmType rightType = binaryExpression.getRightOperand().getEdmType();
    if (rightType == null && resourceEntityType == null) {
      return;
    }
    actualParameterTypes.add(rightType);

    // special case for navigation property (non-)equality comparison with null
    if ("Equality".equals(binOpt.getCategory())
        && (leftType != null && leftType.getKind() == EdmTypeKind.ENTITY
            && rightType == EdmSimpleTypeFacadeImpl.getEdmSimpleType(EdmSimpleTypeKind.Null)
            || leftType == EdmSimpleTypeFacadeImpl.getEdmSimpleType(EdmSimpleTypeKind.Null)
            && rightType != null && rightType.getKind() == EdmTypeKind.ENTITY)) {
      binaryExpression.setEdmType(EdmSimpleTypeFacadeImpl.getEdmSimpleType(EdmSimpleTypeKind.Boolean));
      return;
    }

    final ParameterSet parameterSet = binOpt.validateParameterSet(actualParameterTypes);
    if (parameterSet == null) {
      BinaryExpressionImpl binaryExpressionImpl = (BinaryExpressionImpl) binaryExpression;

      // Tested with TestParserExceptions.TestPMvalidateBinaryOperator
      throw FilterParserExceptionImpl.createINVALID_TYPES_FOR_BINARY_OPERATOR(binaryExpression.getOperator(),
          binaryExpression.getLeftOperand().getEdmType(), binaryExpression.getRightOperand().getEdmType(),
          binaryExpressionImpl.getToken(), curExpression);
    }
    binaryExpression.setEdmType(parameterSet.getReturnType());
  }

  protected void validateMethodTypes(final MethodExpression methodExpression, final Token methodToken)
      throws ExpressionParserException, ExpressionParserInternalError {
    InfoMethod methOpt = availableMethods.get(methodExpression.getUriLiteral());

    List<EdmType> actualParameterTypes = new ArrayList<EdmType>();

    // If there are no parameter then don't perform a type check
    if (methodExpression.getParameters().isEmpty()) {
      return;
    }

    for (CommonExpression parameter : methodExpression.getParameters()) {
      // If there is not at parsing time its not possible to determine the type of eg myPropertyName.
      // Since this should not cause validation errors null type node arguments are leading to bypass
      // the validation
      if (parameter.getEdmType() == null && resourceEntityType == null) {
        return;
      }
      actualParameterTypes.add(parameter.getEdmType());
    }

    ParameterSet parameterSet = methOpt.validateParameterSet(actualParameterTypes);
    // If there is not returntype then the input parameter
    if (parameterSet == null) {
      // Tested with TestParserExceptions.testPMvalidateMethodTypes CASE 1
      throw FilterParserExceptionImpl.createMETHOD_WRONG_INPUT_TYPE((MethodExpressionImpl) methodExpression,
          methodToken, curExpression);
    }
    methodExpression.setEdmType(parameterSet.getReturnType());
  }
  
  /*
   * In case we have + in the string literal and is replaced with ' '(space) in UriParserImpl
   * it needs to be changed back to +
   */
  private String getEncodedUriLiteral(String uriLiteral,int pos) {
	  if (originalFilterString.length()!=0 && uriLiteral.contains(" ")) {
			String encodedUriLiteral = uriLiteral.replaceAll(" ", "+");
			String originalFilterToken = originalFilterString.substring(pos,pos+uriLiteral.length());
			if (originalFilterToken!=null && originalFilterToken.equals(encodedUriLiteral)) {
				decodedFilterString=decodedFilterString.substring(0, pos)+encodedUriLiteral+
						decodedFilterString.substring(pos+uriLiteral.length());
				uriLiteral = encodedUriLiteral;
			}
		}
	  return uriLiteral;
  }   

  static void initAvailTables() {
    Map<String, InfoBinaryOperator> lAvailableBinaryOperators = new HashMap<String, InfoBinaryOperator>();
    Map<String, InfoMethod> lAvailableMethods = new HashMap<String, InfoMethod>();
    Map<String, InfoUnaryOperator> lAvailableUnaryOperators = new HashMap<String, InfoUnaryOperator>();

    // create type validators
    ParameterSetCombination combination = null;
    // create type helpers
    EdmSimpleType boolean_ = EdmSimpleTypeFacadeImpl.getEdmSimpleType(EdmSimpleTypeKind.Boolean);
    EdmSimpleType sbyte = EdmSimpleTypeFacadeImpl.getEdmSimpleType(EdmSimpleTypeKind.SByte);
    EdmSimpleType byte_ = EdmSimpleTypeFacadeImpl.getEdmSimpleType(EdmSimpleTypeKind.Byte);
    EdmSimpleType int16 = EdmSimpleTypeFacadeImpl.getEdmSimpleType(EdmSimpleTypeKind.Int16);
    EdmSimpleType int32 = EdmSimpleTypeFacadeImpl.getEdmSimpleType(EdmSimpleTypeKind.Int32);
    EdmSimpleType int64 = EdmSimpleTypeFacadeImpl.getEdmSimpleType(EdmSimpleTypeKind.Int64);
    EdmSimpleType single = EdmSimpleTypeFacadeImpl.getEdmSimpleType(EdmSimpleTypeKind.Single);
    EdmSimpleType double_ = EdmSimpleTypeFacadeImpl.getEdmSimpleType(EdmSimpleTypeKind.Double);
    EdmSimpleType decimal = EdmSimpleTypeFacadeImpl.getEdmSimpleType(EdmSimpleTypeKind.Decimal);
    EdmSimpleType string = EdmSimpleTypeFacadeImpl.getEdmSimpleType(EdmSimpleTypeKind.String);
    EdmSimpleType time = EdmSimpleTypeFacadeImpl.getEdmSimpleType(EdmSimpleTypeKind.Time);
    EdmSimpleType datetime = EdmSimpleTypeFacadeImpl.getEdmSimpleType(EdmSimpleTypeKind.DateTime);
    EdmSimpleType datetimeoffset = EdmSimpleTypeFacadeImpl.getEdmSimpleType(EdmSimpleTypeKind.DateTimeOffset);
    EdmSimpleType guid = EdmSimpleTypeFacadeImpl.getEdmSimpleType(EdmSimpleTypeKind.Guid);
    EdmSimpleType binary = EdmSimpleTypeFacadeImpl.getEdmSimpleType(EdmSimpleTypeKind.Binary);
    EdmSimpleType null_ = EdmSimpleTypeFacadeImpl.getEdmSimpleType(EdmSimpleTypeKind.Null);

    // ---Member member access---
    lAvailableBinaryOperators.put("/", new InfoBinaryOperator(BinaryOperator.PROPERTY_ACCESS, "Primary", 100,
        new ParameterSetCombination.PSCReturnTypeEqLastParameter()));// todo fix this

    // ---Multiplicative---
    combination = new ParameterSetCombination.PSCflex();
    combination.add(new ParameterSet(sbyte, sbyte, sbyte));
    combination.add(new ParameterSet(byte_, byte_, byte_));
    combination.add(new ParameterSet(int16, int16, int16));
    combination.add(new ParameterSet(int32, int32, int32));
    combination.add(new ParameterSet(int64, int64, int64));
    combination.add(new ParameterSet(single, single, single));
    combination.add(new ParameterSet(double_, double_, double_));
    combination.add(new ParameterSet(decimal, decimal, decimal));
        
    combination.add(new ParameterSet(sbyte, sbyte, null_));
    combination.add(new ParameterSet(sbyte, null_, sbyte));
    combination.add(new ParameterSet(byte_, byte_, null_));
    combination.add(new ParameterSet(byte_, null_, byte_));
    
    combination.add(new ParameterSet(int16, int16, null_));
    combination.add(new ParameterSet(int16, null_, int16));
    combination.add(new ParameterSet(int32, int32, null_));
    combination.add(new ParameterSet(int32, null_, int32));
    combination.add(new ParameterSet(int64, int64, null_));
    combination.add(new ParameterSet(int64, null_, int64));
    
    combination.add(new ParameterSet(single, single, null_));
    combination.add(new ParameterSet(single, null_, single));
    combination.add(new ParameterSet(double_, double_, null_));
    combination.add(new ParameterSet(double_, null_, double_));
    combination.add(new ParameterSet(decimal, decimal, null_));
    combination.add(new ParameterSet(decimal, null_, decimal));

    lAvailableBinaryOperators.put(BinaryOperator.MUL.toUriLiteral(), new InfoBinaryOperator(BinaryOperator.MUL,
        "Multiplicative", 60, combination));
    lAvailableBinaryOperators.put(BinaryOperator.DIV.toUriLiteral(), new InfoBinaryOperator(BinaryOperator.DIV,
        "Multiplicative", 60, combination));
    lAvailableBinaryOperators.put(BinaryOperator.MODULO.toUriLiteral(), new InfoBinaryOperator(BinaryOperator.MODULO,
        "Multiplicative", 60, combination));

    // ---Additive---
    combination = new ParameterSetCombination.PSCflex();
    combination.add(new ParameterSet(sbyte, sbyte, sbyte));
    combination.add(new ParameterSet(byte_, byte_, byte_));
    combination.add(new ParameterSet(int16, int16, int16));
    combination.add(new ParameterSet(int32, int32, int32));
    combination.add(new ParameterSet(int64, int64, int64));
    combination.add(new ParameterSet(single, single, single));
    combination.add(new ParameterSet(double_, double_, double_));
    combination.add(new ParameterSet(decimal, decimal, decimal));
    
    combination.add(new ParameterSet(sbyte, sbyte, null_));
    combination.add(new ParameterSet(sbyte, null_, sbyte));
    combination.add(new ParameterSet(byte_, byte_, null_));
    combination.add(new ParameterSet(byte_, null_, byte_));
    
    combination.add(new ParameterSet(int16, int16, null_));
    combination.add(new ParameterSet(int16, null_, int16));
    combination.add(new ParameterSet(int32, int32, null_));
    combination.add(new ParameterSet(int32, null_, int32));
    combination.add(new ParameterSet(int64, int64, null_));
    combination.add(new ParameterSet(int64, null_, int64));
    
    combination.add(new ParameterSet(single, single, null_));
    combination.add(new ParameterSet(single, null_, single));
    combination.add(new ParameterSet(double_, double_, null_));
    combination.add(new ParameterSet(double_, null_, double_));
    combination.add(new ParameterSet(decimal, decimal, null_));
    combination.add(new ParameterSet(decimal, null_, decimal));

    lAvailableBinaryOperators.put(BinaryOperator.ADD.toUriLiteral(), new InfoBinaryOperator(BinaryOperator.ADD,
        "Additive", 50, combination));
    lAvailableBinaryOperators.put(BinaryOperator.SUB.toUriLiteral(), new InfoBinaryOperator(BinaryOperator.SUB,
        "Additive", 50, combination));

    // ---Relational---
    combination = new ParameterSetCombination.PSCflex();
    combination.add(new ParameterSet(boolean_, string, string));
    combination.add(new ParameterSet(boolean_, time, time));
    combination.add(new ParameterSet(boolean_, datetime, datetime));
    combination.add(new ParameterSet(boolean_, datetimeoffset, datetimeoffset));
    combination.add(new ParameterSet(boolean_, guid, guid));
    combination.add(new ParameterSet(boolean_, sbyte, sbyte));
    combination.add(new ParameterSet(boolean_, byte_, byte_));
    combination.add(new ParameterSet(boolean_, int16, int16));
    combination.add(new ParameterSet(boolean_, int32, int32));
    combination.add(new ParameterSet(boolean_, int64, int64));
    combination.add(new ParameterSet(boolean_, single, single));
    combination.add(new ParameterSet(boolean_, double_, double_));
    combination.add(new ParameterSet(boolean_, decimal, decimal));
    combination.add(new ParameterSet(boolean_, binary, binary));

    combination.add(new ParameterSet(boolean_, string, null_));
    combination.add(new ParameterSet(boolean_, null_, string));
    
    combination.add(new ParameterSet(boolean_, time, null_));
    combination.add(new ParameterSet(boolean_, null_, time));
    
    combination.add(new ParameterSet(boolean_, datetime, null_));
    combination.add(new ParameterSet(boolean_, null_, datetime));
    
    combination.add(new ParameterSet(boolean_, datetimeoffset, null_));
    combination.add(new ParameterSet(boolean_, null_, datetimeoffset));
    
    combination.add(new ParameterSet(boolean_, guid, null_));
    combination.add(new ParameterSet(boolean_, null_, guid));
    
    combination.add(new ParameterSet(boolean_, sbyte, null_));
    combination.add(new ParameterSet(boolean_, null_, sbyte));
    combination.add(new ParameterSet(boolean_, byte_, null_));
    combination.add(new ParameterSet(boolean_, null_, byte_));
    
    combination.add(new ParameterSet(boolean_, int16, null_));
    combination.add(new ParameterSet(boolean_, null_, int16));
    combination.add(new ParameterSet(boolean_, int32, null_));
    combination.add(new ParameterSet(boolean_, null_, int32));
    combination.add(new ParameterSet(boolean_, int64, null_));
    combination.add(new ParameterSet(boolean_, null_, int64));
    
    combination.add(new ParameterSet(boolean_, single, null_));
    combination.add(new ParameterSet(boolean_, null_, single));
    combination.add(new ParameterSet(boolean_, double_, null_));
    combination.add(new ParameterSet(boolean_, null_, double_));
    combination.add(new ParameterSet(boolean_, decimal, null_));
    combination.add(new ParameterSet(boolean_, null_, decimal));
    
    combination.add(new ParameterSet(boolean_, binary, null_));
    combination.add(new ParameterSet(boolean_, null_, binary));
      

    lAvailableBinaryOperators.put(BinaryOperator.LT.toUriLiteral(), new InfoBinaryOperator(BinaryOperator.LT,
        "Relational", 40, combination));
    lAvailableBinaryOperators.put(BinaryOperator.GT.toUriLiteral(), new InfoBinaryOperator(BinaryOperator.GT,
        "Relational", 40, combination));
    lAvailableBinaryOperators.put(BinaryOperator.GE.toUriLiteral(), new InfoBinaryOperator(BinaryOperator.GE,
        "Relational", 40, combination));
    lAvailableBinaryOperators.put(BinaryOperator.LE.toUriLiteral(), new InfoBinaryOperator(BinaryOperator.LE,
        "Relational", 40, combination));

    // ---Equality---
    combination.addFirst(new ParameterSet(boolean_, boolean_, boolean_));
    
    combination.add(new ParameterSet(boolean_, boolean_, null_));
    combination.add(new ParameterSet(boolean_, null_, boolean_));

    lAvailableBinaryOperators.put(BinaryOperator.EQ.toUriLiteral(), new InfoBinaryOperator(BinaryOperator.EQ,
        "Equality", 30, combination));
    lAvailableBinaryOperators.put(BinaryOperator.NE.toUriLiteral(), new InfoBinaryOperator(BinaryOperator.NE,
        "Equality", 30, combination));

    // "---Conditional AND---
    combination = new ParameterSetCombination.PSCflex();
    combination.add(new ParameterSet(boolean_, boolean_, boolean_));
    combination.add(new ParameterSet(boolean_, boolean_, null_));
    combination.add(new ParameterSet(boolean_, null_, boolean_));

    lAvailableBinaryOperators.put(BinaryOperator.AND.toUriLiteral(), new InfoBinaryOperator(BinaryOperator.AND,
        "Conditional", 20, combination));

    // ---Conditional OR---
    combination = new ParameterSetCombination.PSCflex();
    combination.add(new ParameterSet(boolean_, boolean_, boolean_));
    combination.add(new ParameterSet(boolean_, boolean_, null_));
    combination.add(new ParameterSet(boolean_, null_, boolean_));

    lAvailableBinaryOperators.put(BinaryOperator.OR.toUriLiteral(), new InfoBinaryOperator(BinaryOperator.OR,
        "Conditional", 10, combination));

    // endswith
    combination = new ParameterSetCombination.PSCflex();
    combination.add(new ParameterSet(boolean_, string, string));
    lAvailableMethods.put(MethodOperator.ENDSWITH.toUriLiteral(), new InfoMethod(MethodOperator.ENDSWITH, 2, 2,
        combination));

    // indexof
    combination = new ParameterSetCombination.PSCflex();
    combination.add(new ParameterSet(int32, string, string));
    lAvailableMethods.put(MethodOperator.INDEXOF.toUriLiteral(), new InfoMethod(MethodOperator.INDEXOF, 2, 2,
        combination));

    // startswith
    combination = new ParameterSetCombination.PSCflex();
    combination.add(new ParameterSet(boolean_, string, string));
    lAvailableMethods.put(MethodOperator.STARTSWITH.toUriLiteral(), new InfoMethod(MethodOperator.STARTSWITH, 2, 2,
        combination));

    // tolower
    combination = new ParameterSetCombination.PSCflex();
    combination.add(new ParameterSet(string, string));
    lAvailableMethods.put(MethodOperator.TOLOWER.toUriLiteral(), new InfoMethod(MethodOperator.TOLOWER, combination));

    // toupper
    combination = new ParameterSetCombination.PSCflex();
    combination.add(new ParameterSet(string, string));
    lAvailableMethods.put(MethodOperator.TOUPPER.toUriLiteral(), new InfoMethod(MethodOperator.TOUPPER, combination));

    // trim
    combination = new ParameterSetCombination.PSCflex();
    combination.add(new ParameterSet(string, string));
    lAvailableMethods.put(MethodOperator.TRIM.toUriLiteral(), new InfoMethod(MethodOperator.TRIM, combination));

    // substring
    combination = new ParameterSetCombination.PSCflex();
    combination.add(new ParameterSet(string, string, int32));
    combination.add(new ParameterSet(string, string, int32, int32));
    lAvailableMethods.put(MethodOperator.SUBSTRING.toUriLiteral(), new InfoMethod(MethodOperator.SUBSTRING, 1, -1,
        combination));

    // substringof
    combination = new ParameterSetCombination.PSCflex();
    combination.add(new ParameterSet(boolean_, string, string));
    lAvailableMethods.put(MethodOperator.SUBSTRINGOF.toUriLiteral(), new InfoMethod(MethodOperator.SUBSTRINGOF, 1, -1,
        combination));
    
    // replace
    combination = new ParameterSetCombination.PSCflex();
    combination.add(new ParameterSet(string, string, string, string));
    lAvailableMethods.put(MethodOperator.REPLACE.toUriLiteral(), new InfoMethod(MethodOperator.REPLACE, 3, 3,
        combination));

    // concat
    combination = new ParameterSetCombination.PSCflex();
    combination.add(new ParameterSet(string, string, string).setFurtherType(string));
    lAvailableMethods.put(MethodOperator.CONCAT.toUriLiteral(), new InfoMethod(MethodOperator.CONCAT, 2, -1,
        combination));

    // length
    combination = new ParameterSetCombination.PSCflex();
    combination.add(new ParameterSet(int32, string));
    lAvailableMethods.put(MethodOperator.LENGTH.toUriLiteral(), new InfoMethod(MethodOperator.LENGTH, combination));

    // year
    combination = new ParameterSetCombination.PSCflex();
    combination.add(new ParameterSet(int32, datetime));
    lAvailableMethods.put(MethodOperator.YEAR.toUriLiteral(), new InfoMethod(MethodOperator.YEAR, combination));

    // month
    combination = new ParameterSetCombination.PSCflex();
    combination.add(new ParameterSet(int32, datetime));
    lAvailableMethods.put(MethodOperator.MONTH.toUriLiteral(), new InfoMethod(MethodOperator.MONTH, combination));

    // day
    combination = new ParameterSetCombination.PSCflex();
    combination.add(new ParameterSet(int32, datetime));
    lAvailableMethods.put(MethodOperator.DAY.toUriLiteral(), new InfoMethod(MethodOperator.DAY, combination));

    // hour
    combination = new ParameterSetCombination.PSCflex();
    combination.add(new ParameterSet(int32, datetime));
    combination.add(new ParameterSet(int32, time));
    combination.add(new ParameterSet(int32, datetimeoffset));
    lAvailableMethods.put(MethodOperator.HOUR.toUriLiteral(), new InfoMethod(MethodOperator.HOUR, combination));

    // minute
    combination = new ParameterSetCombination.PSCflex();
    combination.add(new ParameterSet(int32, datetime));
    combination.add(new ParameterSet(int32, time));
    combination.add(new ParameterSet(int32, datetimeoffset));
    lAvailableMethods.put(MethodOperator.MINUTE.toUriLiteral(), new InfoMethod(MethodOperator.MINUTE, combination));

    // second
    combination = new ParameterSetCombination.PSCflex();
    combination.add(new ParameterSet(int32, datetime));
    combination.add(new ParameterSet(int32, time));
    combination.add(new ParameterSet(int32, datetimeoffset));
    lAvailableMethods.put(MethodOperator.SECOND.toUriLiteral(), new InfoMethod(MethodOperator.SECOND, combination));

    // round
    combination = new ParameterSetCombination.PSCflex();
    combination.add(new ParameterSet(decimal, decimal));
    combination.add(new ParameterSet(double_, double_));
    lAvailableMethods.put(MethodOperator.ROUND.toUriLiteral(), new InfoMethod(MethodOperator.ROUND, combination));

    // ceiling
    combination = new ParameterSetCombination.PSCflex();
    combination.add(new ParameterSet(decimal, decimal));
    combination.add(new ParameterSet(double_, double_));
    lAvailableMethods.put(MethodOperator.CEILING.toUriLiteral(), new InfoMethod(MethodOperator.CEILING, combination));

    // floor
    combination = new ParameterSetCombination.PSCflex();
    combination.add(new ParameterSet(decimal, decimal));
    combination.add(new ParameterSet(double_, double_));
    lAvailableMethods.put(MethodOperator.FLOOR.toUriLiteral(), new InfoMethod(MethodOperator.FLOOR, combination));

    // ---unary---

    // minus
    combination = new ParameterSetCombination.PSCflex();
    combination.add(new ParameterSet(sbyte, sbyte));
    combination.add(new ParameterSet(byte_, byte_));
    combination.add(new ParameterSet(int16, int16));
    combination.add(new ParameterSet(int32, int32));
    combination.add(new ParameterSet(int64, int64));
    combination.add(new ParameterSet(single, single));
    combination.add(new ParameterSet(double_, double_));
    combination.add(new ParameterSet(decimal, decimal));
    combination.add(new ParameterSet(null_, null_));
    

    // minus
    lAvailableUnaryOperators.put(UnaryOperator.MINUS.toUriLiteral(), new InfoUnaryOperator(UnaryOperator.MINUS,
        "minus", combination));

    // not
    combination = new ParameterSetCombination.PSCflex();
    combination.add(new ParameterSet(boolean_, boolean_));
    combination.add(new ParameterSet(null_, null_));
    lAvailableUnaryOperators.put(UnaryOperator.NOT.toUriLiteral(), new InfoUnaryOperator(UnaryOperator.NOT, "not",
        combination));

    availableBinaryOperators = Collections.unmodifiableMap(lAvailableBinaryOperators);
    availableMethods = Collections.unmodifiableMap(lAvailableMethods);
    availableUnaryOperators = Collections.unmodifiableMap(lAvailableUnaryOperators);
  }
}