* Copyright (c) 2006, 2011 Oracle. All rights reserved.

* This program and the accompanying materials are made available under the

* terms of the Eclipse Public License v1.0 and Eclipse Distribution License v. 1.0

* which accompanies this distribution.

* The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html

* and the Eclipse Distribution License is available at

* http://www.eclipse.org/org/documents/edl-v10.php.

*

* Contributors:

*     Oracle - initial API and implementation

*

******************************************************************************/

* This visitor gathers the problems and warnings found in a query by validating its semantic. The

* grammar is not validating here.

* <p>

* For instance, the function <b>AVG</b> accepts a state field path. The property it represents has

* to be of numeric type. <b>AVG(e.name)</b> is parsable but is not semantically valid because the

* type of name is a string (the property signature is: "<code>private String name</code>").

*

* @see GrammarValidator

*

* @version 2.3.1

* @since 2.3

* @author Pascal Filion

*/

  /**

   * This visitor is responsible to retrieve the visited {@link Expression} if it is a

   * {@link CollectionValuedPathExpression}.

   */

  private CollectionValuedPathExpressionVisitor collectionValuedPathExpressionVisitor;

  /**

   * This validator determines whether the {@link Expression} visited represents

   * {@link Expression#NULL}.

   */

  private NullValueVisitor nullValueVisitor;

  /**

   * This flag is used to register the {@link IdentificationVariable IdentificationVariables} that

   * are used throughout the query (top-level query and subqueries), except the identification

   * variables defining an abstract schema name or a collection-valued path expression.

   */

  private boolean registerIdentificationVariable;

  /**

   * This visitor is responsible to retrieve the visited {@link Expression} if it is a

   * {@link StateFieldPathExpression}.

   */

  private StateFieldPathExpressionVisitor stateFieldPathExpressionVisitor;

  /**

   * This finder is responsible to retrieve the abstract schema name from the <b>UPDATE</b> range

   * declaration expression.

   */

  private UpdateClauseAbstractSchemaNameFinder updateClauseAbstractSchemaNameFinder;

  /**

   * The {@link IdentificationVariable IdentificationVariables} that are used throughout the query

   * (top-level query and subqueries), except the identification variables defining an abstract

   * schema name or a collection-valued path expression.

   */

  private List<IdentificationVariable> usedIdentificationVariables;

  /**

   * The {@link TypeValidator TypeVlidators} mapped to their Java class. Those validators validate

   * any {@link Expression} by making sure its type matches the desired type.

   */

  private Map<Class<? extends TypeValidator>, TypeValidator> validators;

  /**

   * This finder is responsible to retrieve the virtual identification variable from the

   * <b>UPDATE</b> range declaration since it is optional.

   */

  private VirtualIdentificationVariableFinder virtualIdentificationVariableFinder;

  /**

   * Creates a new <code>SemanticValidator</code>.

   *

   * @param queryContext The context used to query information about the query

   */

  public SemanticValidator(JPQLQueryContext queryContext) {

    super(queryContext);

  }

  @SuppressWarnings("null")

  private void addIdentificationVariable(IdentificationVariable identificationVariable,

                                         Map<String, List<IdentificationVariable>> identificationVariables) {

    String variableName = (identificationVariable != null) ? identificationVariable.getText() : null;

    if (ExpressionTools.stringIsNotEmpty(variableName)) {

      // Make sure the identification variable is uppercase since a JPQL uses case insensitive

      // identification variables

      variableName = variableName.toUpperCase();

      // Add the IdentificationVariable to the list

      List<IdentificationVariable> variables = identificationVariables.get(variableName);

      if (variables == null) {

        variables = new ArrayList<IdentificationVariable>();

        identificationVariables.put(variableName, variables);

      }

      variables.add(identificationVariable);

    }

  }

  private boolean areConstructorParametersEquivalent(ITypeDeclaration[] types1, IType[] types2) {

    if ((types1.length == 0) || (types2.length == 0)) {

      return types2.length == types2.length;

    }

    if (types1.length != types1.length) {

      return false;

    }

    TypeHelper typeHelper = getTypeHelper();

    for (int index = types1.length; --index >= 0; ) {

      // Convert a primitive to its Object type

      IType type1 = typeHelper.convertPrimitive(types1[index].getType());

      IType type2 = typeHelper.convertPrimitive(types2[index]);

      if (!type1.isAssignableTo(type2)) {

        return false;

      }

    }

    return true;

  }

  private Resolver buildStateFieldResolver(Resolver parentResolver, String path) {

    Resolver resolver = parentResolver.getChild(path);

    if (resolver == null) {

      resolver = new StateFieldResolver(parentResolver, path, null);

    }

    return resolver;

  }

  private void collectAllDeclarationIdentificationVariables(Map<String, List<IdentificationVariable>> identificationVariables) {

    JPQLQueryContext context = queryContext.getCurrentContext();

    while (context != null) {

      collectDeclarationIdentificationVariables(context, identificationVariables);

      context = context.getParent();

    }

  }

  private void collectDeclarationIdentificationVariables(JPQLQueryContext queryContext,

                                                         Map<String, List<IdentificationVariable>> identificationVariables) {

    for (Declaration declaration : queryContext.getActualDeclarationResolver().getDeclarations()) {

      // Register the identification variable from the base expression

      IdentificationVariable identificationVariable = declaration.identificationVariable;

      addIdentificationVariable(identificationVariable, identificationVariables);

      // Register the identification variable from the JOIN expressions

      for (IdentificationVariable joinIdentificationVariable : declaration.joins.values()) {

        addIdentificationVariable(joinIdentificationVariable, identificationVariables);

      }

    }

  }

  private CollectionValuedPathExpression collectionValuedPathExpression(Expression expression) {

    CollectionValuedPathExpressionVisitor visitor = collectionValuedPathExpressionVisitor();

    try {

      expression.accept(visitor);

      return visitor.expression;

    }

    finally {

      visitor.expression = null;

    }

  }

  private CollectionValuedPathExpressionVisitor collectionValuedPathExpressionVisitor() {

    if (collectionValuedPathExpressionVisitor == null) {

      collectionValuedPathExpressionVisitor = new CollectionValuedPathExpressionVisitor();

    }

    return collectionValuedPathExpressionVisitor;

  }

  /**

   * {@inheritDoc}

   */

  @Override

  public void dispose() {

    super.dispose();

    usedIdentificationVariables.clear();

  }

  private AbstractSchemaName findAbstractSchemaName(UpdateItem expression) {

    UpdateClauseAbstractSchemaNameFinder visitor = updateClauseAbstractSchemaNameFinder();

    try {

      expression.accept(visitor);

      return visitor.expression;

    }

    finally {

      visitor.expression = null;

    }

  }

  private IdentificationVariable findVirtualIdentificationVariable(AbstractSchemaName expression) {

    VirtualIdentificationVariableFinder visitor = virtualIdentificationVariableFinder();

    try {

      expression.accept(visitor);

      return visitor.expression;

    }

    finally {

      visitor.expression = null;

    }

  }

  /**

   * {@inheritDoc}

   */

  @Override

  protected void initialize() {

    super.initialize();

    validators                     = new HashMap<Class<? extends TypeValidator>, TypeValidator>();

    usedIdentificationVariables    = new ArrayList<IdentificationVariable>();

    registerIdentificationVariable = true;

  }

  /**

   * Determines whether the given {@link Expression} is of the correct type based on these rules:

   * <ul>

   * <li>The {@link Expression} returns a boolean value;</li>

   * </ul>

   *

   * @param expression The {@link Expression} to validate

   * @return <code>true</code> if the given {@link Expression} passes the checks; <code>false</code>

   * otherwise

   */

  private boolean isBooleanType(Expression expression) {

    return isValid(expression, BooleanTypeValidator.class);

  }

  private boolean isComparisonEquivalentType(Expression expression1, Expression expression2) {

    IType type1 = getType(expression1);

    IType type2 = getType(expression2);

    // 1. The types are the same

    // 2. The type cannot be determined, pretend they are equivalent,

    //    another rule will validate it

    // 3. One is assignable to the other one

    TypeHelper typeHelper = getTypeHelper();

    return (type1 == type2) ||

           !type1.isResolvable() ||

           !type2.isResolvable() ||

            typeHelper.isNumericType(type1) && typeHelper.isNumericType(type2) ||

            typeHelper.isDateType(type1)    && typeHelper.isDateType(type2)    ||

            type1.isAssignableTo(type2) ||

            type2.isAssignableTo(type1);

  }

  private boolean isEquivalentBetweenType(Expression expression1, Expression expression2) {

    IType type1 = getType(expression1);

    IType type2 = getType(expression2);

    // The type cannot be determined, pretend they are equivalent,

    // another rule will validate it

    if (!type1.isResolvable() || !type2.isResolvable()) {

      return true;

    }

    TypeHelper typeHelper = getTypeHelper();

    if (type1 == type2) {

      return typeHelper.isNumericType(type1) ||

      typeHelper.isStringType(type1)  ||

      typeHelper.isDateType(type1);

    }

    else {

      return typeHelper.isNumericType(type1) && typeHelper.isNumericType(type2) ||

             typeHelper.isStringType(type1)  && typeHelper.isStringType(type2)  ||

             typeHelper.isDateType(type1)    && typeHelper.isDateType(type2);

    }

  }

  /**

   * Determines whether the given {@link Expression} is of the correct type based on these rules:

   * <ul>

   * <li>The {@link Expression}'s type is an integral type (long or integer).</li>

   * </ul>

   *

   * @param expression The {@link Expression} to validate

   * @return <code>true</code> if the given {@link Expression} passes the checks; <code>false</code>

   * otherwise

   */

  private boolean isIntegralType(Expression expression) {

    if (isNumericType(expression)) {

      TypeHelper typeHelper = getTypeHelper();

      IType type = getType(expression);

      if (type != typeHelper.unknownType()) {

        return typeHelper.isIntegralType(type);

      }

    }

    return false;

  }

  private boolean isNullValue(Expression expression) {

    NullValueVisitor visitor = nullValueVisitor();

    try {

      expression.accept(visitor);

      return visitor.valid;

    }

    finally {

      visitor.valid = false;

    }

  }

  /**

   * Determines whether the given {@link Expression} is of the correct type based on these rules:

   * <ul>

   * <li>The {@link Expression} returns a numeric value;</li>

   * </ul>

   *

   * @param expression The {@link Expression} to validate

   * @return <code>true</code> if the given {@link Expression} passes the checks; <code>false</code>

   * otherwise

   */

  private boolean isNumericType(Expression expression) {

    return isValid(expression, NumericTypeValidator.class);

  }

  /**

   * Determines whether the given {@link Expression} is of the correct type based on these rules:

   * <ul>

   * <li>The {@link Expression}'s type is a string type.</li>

   * </ul>

   *

   * @param expression The {@link Expression} to validate

   * @return <code>true</code> if the given {@link Expression} passes the checks; <code>false</code>

   * otherwise

   */

  private boolean isStringType(Expression expression) {

    return isValid(expression, StringTypeValidator.class);

  }

  /**

   * Determines whether the given {@link Expression} is of the correct type by using the

   * {@link TypeValidator}.

   *

   * @param expression The {@link Expression} to validate

   * @param validatorClass The Java class of the {@link TypeValidator} that will determine if the

   * given {@link Expression} has the right type

   * @return <code>true</code> if the given {@link Expression} passes the checks; <code>false</code>

   * otherwise

   */

  private boolean isValid(Expression expression, Class<? extends TypeValidator> validatorClass) {

    TypeValidator validator = validator(validatorClass);

    try {

      expression.accept(validator);

      return validator.valid;

    }

    finally {

      validator.valid = false;

    }

  }

  private NullValueVisitor nullValueVisitor() {

    if (nullValueVisitor == null) {

      nullValueVisitor = new NullValueVisitor();

    }

    return nullValueVisitor;

  }

  private StateFieldPathExpression stateFieldPathExpression(Expression expression) {

    StateFieldPathExpressionVisitor visitor = stateFieldPathExpressionVisitor();

    try {

      expression.accept(visitor);

      return visitor.expression;

    }

    finally {

      visitor.expression = null;

    }

  }

  private StateFieldPathExpressionVisitor stateFieldPathExpressionVisitor() {

    if (stateFieldPathExpressionVisitor == null) {

      stateFieldPathExpressionVisitor = new StateFieldPathExpressionVisitor();

    }

    return stateFieldPathExpressionVisitor;

  }

  private UpdateClauseAbstractSchemaNameFinder updateClauseAbstractSchemaNameFinder() {

    if (updateClauseAbstractSchemaNameFinder == null) {

      updateClauseAbstractSchemaNameFinder = new UpdateClauseAbstractSchemaNameFinder();

    }

    return updateClauseAbstractSchemaNameFinder;

  }

  private void validateAggregateFunction(AggregateFunction expression) {

    // Arguments to the functions MAX/MIN must correspond to orderable state field types (i.e.,

    // numeric types, string types, character types, or date types)

    StateFieldPathExpression pathExpression = stateFieldPathExpression(expression.getExpression());

    if (pathExpression != null) {

      validateStateFieldPathExpression(pathExpression, false);

    }

  }

  /**

   * Determines whether the given {@link Expression} is of the correct type based on these rules:

   * <ul>

   * <li>The {@link Expression} returns a boolean value;</li>

   * <li>The {@link Expression}'s type is a boolean type.</li>

   * </ul>

   *

   * @param expression The {@link Expression} to validate

   * @param messageKey The key used to retrieve the localized message describing the problem

   */

  private void validateBooleanType(Expression expression, String messageKey) {

    if (isValid(expression, BooleanPrimaryBNF.ID) && !isBooleanType(expression)) {

      addProblem(expression, messageKey);

    }

  }

  private void validateCollectionValuedPathExpression(Expression expression,

                                                      boolean collectionTypeOnly) {

    // The path expression resolves to a collection-valued path expression

    CollectionValuedPathExpression collectionValuedPathExpression = collectionValuedPathExpression(expression);

    if (collectionValuedPathExpression != null &&

        collectionValuedPathExpression.hasIdentificationVariable() &&

       !collectionValuedPathExpression.endsWithDot()) {

      // A collection_valued_field is designated by the name of an association field in a

      // one-to-many or a many-to-many relationship or by the name of an element collection field

      Resolver resolver = getResolver(expression);

      IType type = resolver.getType();

      IMapping mapping = resolver.getMapping();

      // Does not resolve to a valid path

      if (!type.isResolvable() || (mapping == null)) {

        int startIndex = position(expression);

        int endIndex   = startIndex + length(expression);

        addProblem(

          expression,

          startIndex,

          endIndex,

          CollectionValuedPathExpression_NotResolvable,

          expression.toParsedText()

        );

      }

      else if (collectionTypeOnly && !MappingTypeHelper.isCollectionMapping(mapping) ||

              !collectionTypeOnly && !MappingTypeHelper.isRelationshipMapping(mapping)) {

        int startIndex = position(expression);

        int endIndex   = startIndex + length(expression);

        addProblem(

          expression,

          startIndex,

          endIndex,

          CollectionValuedPathExpression_NotCollectionType,

          expression.toParsedText()

        );

      }

    }

  }

  private void validateIdentificationVariables() {

    // Collect the identification variables from the Declarations

    Map<String, List<IdentificationVariable>> identificationVariables = new HashMap<String, List<IdentificationVariable>>();

    collectDeclarationIdentificationVariables(queryContext.getCurrentContext(), identificationVariables);

    // Check for duplicate identification variables

    for (Map.Entry<String, List<IdentificationVariable>> entry : identificationVariables.entrySet()) {

      List<IdentificationVariable> variables = entry.getValue();

      if (variables.size() > 1) {

        for (IdentificationVariable variable : variables) {

          addProblem(variable, IdentificationVariable_Invalid_Duplicate, variable.getText());

        }

      }

    }

    // Now collect the identification variables from the parent queries

    identificationVariables.clear();

    collectAllDeclarationIdentificationVariables(identificationVariables);

    // Check for undeclared identification variables

    for (IdentificationVariable identificationVariable : usedIdentificationVariables) {

      String variableName = identificationVariable.getText();

      if (ExpressionTools.stringIsNotEmpty(variableName) &&

          !identificationVariables.containsKey(variableName.toUpperCase())) {

        addProblem(identificationVariable, IdentificationVariable_Invalid_NotDeclared, variableName);

      }

    }

  }

  /**

   * Determines whether the given {@link Expression} is of the correct type based on these rules:

   * <ul>

   * <li>The {@link Expression} returns a integral value;</li>

   * <li>The {@link Expression}'s type is an integral type (long or integer).</li>

   * </ul>

   *

   * @param expression The {@link Expression} to validate

   * @param messageKey The key used to retrieve the localized message describing the problem

   */

  private void validateIntegralType(Expression expression, String messageKey) {

    if (isValid(expression, SimpleArithmeticExpressionBNF.ID) &&

       !isIntegralType(expression)) {

      addProblem(expression, messageKey);

    }

  }

  private void validateMapIdentificationVariable(EncapsulatedIdentificationVariableExpression expression) {

    // The KEY, VALUE, and ENTRY operators may only be applied to

    // identification variables that correspond to map-valued associations

    // or map-valued element collections

    if (expression.hasExpression()) {

      Expression childExpression = expression.getExpression();

      String variableName = queryContext.literal(childExpression, LiteralType.IDENTIFICATION_VARIABLE);

      // Retrieve the identification variable's type without traversing the type parameters

      if (ExpressionTools.stringIsNotEmpty(variableName)) {

        ITypeDeclaration typeDeclaration = getTypeDeclaration(childExpression);

        if (!getTypeHelper().isMapType(typeDeclaration.getType())) {

          addProblem(

            childExpression,

            EncapsulatedIdentificationVariableExpression_NotMapValued,

            expression.getIdentifier()

          );

        }

      }

    }

  }

  /**

   * Determines whether the given {@link Expression} is of the correct type based on these rules:

   * <ul>

   * <li>The {@link Expression} returns a numeric value;</li>

   * <li>The {@link Expression}'s type is an numeric type.</li>

   * </ul>

   *

   * @param expression The {@link Expression} to validate

   * @param messageKey The key used to retrieve the localized message describing the problem

   */

  private void validateNumericType(Expression expression, String messageKey) {

    if (isValid(expression, SimpleArithmeticExpressionBNF.ID) && !isNumericType(expression)) {

      addProblem(expression, messageKey);

    }

  }

  /**

   * Validates the given {@link StateFieldPathExpression}.

   *

   * @param expression The {@link StateFieldPathExpression} the validate

   * @param associationFieldValid Determines whether an association field is a valid type

   * @return <code>true</code> if the path expression is a state field path expression; <code>false</code>

   * if it's actually a fully qualified enum constant.

   */

  private boolean validateStateFieldPathExpression(StateFieldPathExpression expression,

                                                   boolean associationFieldValid) {

    // A single_valued_object_field is designated by the name of an association field in a

    // one-to-one or many-to-one relationship or a field of embeddable class type

    if (expression.hasIdentificationVariable() &&

       !expression.endsWithDot()) {

      IType type = getType(expression);

      IMapping mapping = getMapping(expression);

      // Does not resolve to a valid path

      if (!type.isResolvable()) {

        addProblem(expression, StateFieldPathExpression_NotResolvable, expression.toParsedText());

      }

      // Make sure an enum constant was parsed as a state field path

      // expression before checking for a mapping

      else if ((mapping == null) && type.isEnum()) {

        String enumConstant = expression.getPath(expression.pathSize() - 1);

        boolean found = false;

        for (String constant : type.getEnumConstants()) {

          if (constant.equals(enumConstant)) {

            found = true;

            break;

          }

        }

        if (!found) {

          int startIndex = position(expression) + type.getName().length() + 1;

          int endIndex   = startIndex + enumConstant.length();

          addProblem(expression, startIndex, endIndex, StateFieldPathExpression_InvalidEnumConstant, enumConstant);

        }

        // Remove the used identification variable since it's is the first

        // package name of the fully qualified enum constant

        usedIdentificationVariables.remove(expression.getIdentificationVariable());

      }

      else {

        // No mapping can be found for that path, it could be a transient mapping

        if (MappingTypeHelper.isTransientMapping(mapping)) {

          addProblem(expression, StateFieldPathExpression_NoMapping, expression.toParsedText());

        }

        // It is syntactically illegal to compose a path expression from a path expression that

        // evaluates to a collection

        else if (MappingTypeHelper.isCollectionMapping(mapping)) {

          addProblem(expression, StateFieldPathExpression_CollectionType, expression.toParsedText());

        }

        // For instance, MAX and MIN don't evaluate to an association field

        else if (!associationFieldValid && MappingTypeHelper.isRelationshipMapping(mapping)) {

          addProblem(expression, StateFieldPathExpression_AssociationField, expression.toParsedText());

        }

        return true;

      }