* Copyright (c) 2006, 2013 Oracle and/or its affiliates. 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 {@link IJPQLQueryFormatter} is used to generate a string representation of a {@link

* StateObject} based on how it was parsed, which means this formatter can only be used when the

* {@link StateObject} was created by parsing a JPQL query because it needs to retrieve parsing

* information from the corresponding {@link Expression}.

* <p>

* It is possible to partially match the JPQL query that was parsed, the value of <em>exactMatch</em>

* will determine whether the string representation of any given {@link StateObject} should reflect

* the exact string that was parsed. <code>true</code> will use every bit of information contained

* in the corresponding {@link Expression} to perfectly match what was parsed (case of JPQL

* identifiers and the presence of whitespace); <code>false</code> will only match the case

* sensitivity of the JPQL identifiers.

*

* @version 2.4

* @since 2.4

* @author Pascal Filion

*/

  /**

   * Determines whether the string representation of any given {@link StateObject} should reflect

   * the exact string that was parsed: <code>true</code> will use every bit of information

   * contained in the corresponding {@link Expression} to perfectly match what was parsed;

   * <code>false</code> will only match the case sensitivity of the JPQL identifiers.

   */

  protected final boolean exactMatch;

  /**

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

   *

   * @param exactMatch Determines whether the string representation of any given {@link StateObject}

   * should reflect the exact string that was parsed: <code>true</code> will use every bit of

   * information contained in the corresponding {@link Expression} to perfectly match what was

   * parsed (case of JPQL identifiers and the presence of whitespace); <code>false</code> will only

   * match the case sensitivity of the JPQL identifiers

   */

  protected AbstractActualJPQLQueryFormatter(boolean exactMatch) {

    super(IdentifierStyle.UPPERCASE);

    this.exactMatch = exactMatch;

  }

  /**

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

   *

   * @param exactMatch Determines whether the string representation of any given {@link StateObject}

   * should reflect the exact string that was parsed: <code>true</code> will use every bit of

   * information contained in the corresponding {@link Expression} to perfectly match what was

   * parsed (case of JPQL identifiers and the presence of whitespace); <code>false</code> will only

   * match the case sensitivity of the JPQL identifiers

   * @param style Determines how the JPQL identifiers are written out, which is used if the

   * {@link StateObject} was modified after its creation

   * @exception NullPointerException The IdentifierStyle cannot be <code>null</code>

   */

  protected AbstractActualJPQLQueryFormatter(boolean exactMatch, IdentifierStyle style) {

    super(style);

    this.exactMatch = exactMatch;

  }

  /**

   * Appends the given actual identifier if it's not an empty string, otherwise the second

   * identifier will be appended.

   *

   * @param actualIdentifier The actual JPQL identifier to append to the writer if it's not an

   * empty string

   * @param identifier The uppercase constant of the JPQL identifier to append if the actual one is

   * an empty string

   */

  protected void appendIdentifier(String actualIdentifier, String identifier) {

    if (!exactMatch || ExpressionTools.stringIsEmpty(actualIdentifier)) {

      actualIdentifier = formatIdentifier(identifier);

    }

    writer.append(actualIdentifier);

  }

  /**

   * Determines whether the string representation of any given {@link StateObject} should reflect

   * the exact string that was parsed.

   *

   * @return <code>true</code> will use every bit of information contained in the corresponding

   * {@link Expression} to perfectly match what was parsed; <code>false</code> will only match the

   * case sensitivity of the JPQL identifiers

   */

  public boolean isUsingExactMatch() {

    return exactMatch;

  }

  protected boolean shouldOutput(Expression expression) {

    return !exactMatch || (expression == null);

  }

  protected void toStringAggregateFunction(AggregateFunctionStateObject stateObject) {

    if (stateObject.isDecorated()) {

      toText(stateObject);

    }

    else {

      AggregateFunction expression = stateObject.getExpression();

      // Identifier

      appendIdentifier((expression != null) ? expression.getActualIdentifier() : stateObject.getIdentifier(), stateObject.getIdentifier());

      // '('

      if (shouldOutput(expression) || expression.hasLeftParenthesis()) {

        writer.append(formatIdentifier(LEFT_PARENTHESIS));

      }

      // 'DISTINCT'

      if (stateObject.hasDistinct()) {

        appendIdentifier((expression != null) ? expression.getActualDistinctIdentifier() : DISTINCT, DISTINCT);

        if (shouldOutput(expression) || expression.hasSpaceAfterDistinct()) {

          writer.append(SPACE);

        }

      }

      // Encapsulated expression

      if (stateObject.hasStateObject()) {

        stateObject.getStateObject().accept(this);

      }

      // ')'

      if (shouldOutput(expression) || expression.hasRightParenthesis()) {

        writer.append(formatIdentifier(RIGHT_PARENTHESIS));

      }

    }

  }

  protected void toStringChildren(ListHolderStateObject<? extends StateObject> stateObject,

                                  boolean comma) {

    for (ListIterator<? extends StateObject> iter = stateObject.items(); iter.hasNext(); ) {

      iter.next().accept(this);

      if (iter.hasNext()) {

        writer.append(comma ? COMMA_SPACE : SPACE);

      }

    }

  }

  protected void toStringCompound(CompoundExpressionStateObject stateObject, String identifier) {

    if (stateObject.isDecorated()) {

      toText(stateObject);

    }

    else {

      CompoundExpression expression = stateObject.getExpression();

      // Left expression

      if (stateObject.hasLeft()) {

        stateObject.getLeft().accept(this);

        writer.append(SPACE);

      }

      // Identifier

      appendIdentifier((expression != null) ? expression.getActualIdentifier() : identifier, identifier);

      if (shouldOutput(expression) || expression.hasSpaceAfterIdentifier()) {

        writer.append(SPACE);

      }

      // Right expression

      if (stateObject.hasRight()) {

        stateObject.getRight().accept(this);

      }

    }

  }

  protected void toStringDoubleEncapsulated(AbstractDoubleEncapsulatedExpressionStateObject stateObject) {

    if (stateObject.isDecorated()) {

      toText(stateObject);

    }

    else {

      AbstractDoubleEncapsulatedExpression expression = stateObject.getExpression();

      // Identifier

      appendIdentifier((expression != null) ? expression.getActualIdentifier() : stateObject.getIdentifier(), stateObject.getIdentifier());

      // '('

      if (shouldOutput(expression) || expression.hasLeftParenthesis()) {

        writer.append(LEFT_PARENTHESIS);

      }

      else if (expression.hasSpaceAfterIdentifier()) {

        writer.append(COMMA);

      }

      // First expression

      if (stateObject.hasFirst()) {

        stateObject.getFirst().accept(this);

      }

      // ','

      if (shouldOutput(expression) || expression.hasComma()) {

        writer.append(COMMA);

      }

      if (shouldOutput(expression) || expression.hasSpaceAfterComma()) {

        writer.append(SPACE);

      }

      // Second expression

      if (stateObject.hasSecond()) {

        stateObject.getSecond().accept(this);

      }

      // ')'

      if (shouldOutput(expression) || expression.hasRightParenthesis()) {

        writer.append(RIGHT_PARENTHESIS);

      }

    }

  }

  protected void toStringEncapsulatedIdentificationVariable(EncapsulatedIdentificationVariableExpressionStateObject stateObject) {

    if (stateObject.isDecorated()) {

      toText(stateObject);

    }

    else {

      EncapsulatedIdentificationVariableExpression expression = stateObject.getExpression();

      // Identifier

      appendIdentifier((expression != null) ? expression.getActualIdentifier() : stateObject.getIdentifier(), stateObject.getIdentifier());

      // '('

      if (shouldOutput(expression) || expression.hasLeftParenthesis()) {

        writer.append(LEFT_PARENTHESIS);

      }

      // Identification variable

      if (stateObject.hasIdentificationVariable()) {

        writer.append(stateObject.getIdentificationVariable());

      }

      // ')'

      if (shouldOutput(expression) || expression.hasRightParenthesis()) {

        writer.append(RIGHT_PARENTHESIS);

      }

    }

  }

  protected void toStringFromClause(AbstractFromClauseStateObject stateObject) {

    if (stateObject.isDecorated()) {

      toText(stateObject);

    }

    else {

      AbstractFromClause expression = stateObject.getExpression();

      // 'FROM'

      appendIdentifier((expression != null) ? expression.getActualIdentifier() : FROM, FROM);

      if (shouldOutput(expression) || expression.hasSpaceAfterFrom()) {

        writer.append(SPACE);

      }

      // declaration

      if (stateObject.hasItems()) {

        toStringChildren(stateObject, true);

      }

    }

  }

  protected void toStringIdentificationVariableDeclaration(AbstractIdentificationVariableDeclarationStateObject stateObject) {

    if (stateObject.isDecorated()) {

      toText(stateObject);

    }

    else {

      IdentificationVariableDeclaration expression = stateObject.getExpression();

      // Range variable declaration

      stateObject.getRangeVariableDeclaration().accept(this);

      // Join | Join Fetch

      if (stateObject.hasItems()) {

        if (shouldOutput(expression) || expression.hasSpace()) {

          writer.append(SPACE);

        }

        toStringChildren(stateObject, false);

      }

    }

  }

  protected void toStringModifyStatement(AbstractModifyStatementStateObject stateObject) {

    if (stateObject.isDecorated()) {

      toText(stateObject);

    }

    else {

      stateObject.getModifyClause().accept(this);

      if (stateObject.hasWhereClause()) {

        // TODO: HANDLE SPACE

        writer.append(SPACE);

        stateObject.getWhereClause().accept(this);

      }

    }

  }

  protected void toStringPathExpression(AbstractPathExpressionStateObject stateObject) {

    if (stateObject.isDecorated()) {

      toText(stateObject);

    }

    else {

      stateObject.toText(writer);

    }

  }

  protected void toStringRangeVariableDeclaration(AbstractRangeVariableDeclarationStateObject stateObject) {

    if (stateObject.isDecorated()) {

      toText(stateObject);

    }

    else {

      RangeVariableDeclaration expression = stateObject.getExpression();

      // "Root" object (abstract schema name or derived declaration)

      stateObject.getRootStateObject().accept(this);

      if (exactMatch && (expression != null) && expression.hasSpaceAfterRootObject()) {

        writer.append(SPACE);

      }

      // 'AS'

      if (stateObject.hasAs()) {

        if (!exactMatch || (expression == null)) {

          writer.append(SPACE);

        }

        appendIdentifier((expression != null) ? expression.getActualAsIdentifier() : AS, AS);

      }

      if (exactMatch && (expression != null) && expression.hasSpaceAfterAs()) {

        writer.append(SPACE);

      }

      // Identification variable

      if (stateObject.hasIdentificationVariable() &&

         !stateObject.isIdentificationVariableVirtual()) {

        if (!exactMatch || (expression == null)) {

          writer.append(SPACE);

        }

        writer.append(stateObject.getIdentificationVariable());

      }

    }

  }

  protected boolean toStringSelectStatement(AbstractSelectStatementStateObject stateObject) {

    AbstractSelectStatement expression = stateObject.getExpression();

    boolean spaceAdded = false;

    // SELECT clause

    stateObject.getSelectClause().accept(this);

    // If no select items were parsed by they got added later, make sure a space is added

    if (shouldOutput(expression) ||

        expression.hasSpaceAfterSelect() ||

        (!expression.getSelectClause().hasSelectExpression() &&

         stateObject.getSelectClause().hasSelectItem())) {

      writer.append(SPACE);

    }

    // FROM clause

    stateObject.getFromClause().accept(this);

    // If no WHERE clause was parsed but was added later, make sure a space is added

    if (exactMatch && (expression != null) && expression.hasSpaceAfterFrom() ||

        stateObject.hasWhereClause()) {

      writer.append(SPACE);

      spaceAdded = true;

    }

    // WHERE clause

    if (stateObject.hasWhereClause()) {

      stateObject.getWhereClause().accept(this);

      spaceAdded = false;

    }

    // If no GROUP BY clause was parsed but was added later, make sure a space is added

    if (exactMatch && (expression != null) && expression.hasSpaceAfterWhere() ||

        stateObject.hasGroupByClause()) {

      if (!spaceAdded) {

        writer.append(SPACE);

        spaceAdded = true;

      }

    }

    // GROUP BY clause

    if (stateObject.hasGroupByClause()) {

      stateObject.getGroupByClause().accept(this);

      spaceAdded = false;

    }

    // If no HAVING clause was parsed but was added later, make sure a space is added

    if (exactMatch && (expression != null) && expression.hasSpaceAfterGroupBy() ||

        stateObject.hasHavingClause()) {

      if (!spaceAdded) {

        writer.append(SPACE);

        spaceAdded = true;

      }

    }

    // HAVING clause

    if (stateObject.hasHavingClause()) {

      stateObject.getHavingClause().accept(this);

      spaceAdded = true;

    }

    return spaceAdded;

  }

  protected void toStringSimpleStateObject(SimpleStateObject stateObject) {

    if (stateObject.isDecorated()) {

      toText(stateObject);

    }

    else if (stateObject.hasText()) {

      writer.append(stateObject.getText());

    }

  }

  protected void toStringSingleEncapsulated(AbstractSingleEncapsulatedExpressionStateObject stateObject) {

    if (stateObject.isDecorated()) {

      toText(stateObject);

    }

    else {

      AbstractSingleEncapsulatedExpression expression = stateObject.getExpression();

      // Identifier

      appendIdentifier((expression != null) ? expression.getActualIdentifier() : stateObject.getIdentifier(), stateObject.getIdentifier());

      // '('

      if (shouldOutput(expression) || expression.hasLeftParenthesis()) {

        writer.append(LEFT_PARENTHESIS);

      }

      if (stateObject.hasStateObject()) {

        stateObject.getStateObject().accept(this);

      }

      // ')'

      if (shouldOutput(expression) || expression.hasRightParenthesis()) {

        writer.append(RIGHT_PARENTHESIS);

      }

    }

  }

  protected void toStringTripleEncapsulated(AbstractTripleEncapsulatedExpressionStateObject stateObject) {

    if (stateObject.isDecorated()) {

      toText(stateObject);

    }

    else {

      AbstractTripleEncapsulatedExpression expression = stateObject.getExpression();

      // Identifier

      appendIdentifier((expression != null) ? expression.getActualIdentifier() : stateObject.getIdentifier(), stateObject.getIdentifier());

      // '('

      if (shouldOutput(expression) || expression.hasLeftParenthesis()) {

        writer.append(LEFT_PARENTHESIS);

      }

      // First expression

      if (stateObject.hasFirst()) {

        stateObject.getFirst().accept(this);

      }

      if (shouldOutput(expression) || expression.hasFirstComma()) {

        writer.append(COMMA);

      }

      if (shouldOutput(expression) || expression.hasSpaceAfterFirstComma()) {

        writer.append(SPACE);

      }

      // Second expression

      if (stateObject.hasSecond()) {

        stateObject.getSecond().accept(this);

      }

      // Third expression

      if (stateObject.hasThird()) {

        if (shouldOutput(expression) || expression.hasSecondComma()) {

          writer.append(COMMA);

        }

        if (shouldOutput(expression) || expression.hasSpaceAfterSecondComma()) {

          writer.append(SPACE);

        }

        stateObject.getThird().accept(this);

      }

      // ')'

      if (shouldOutput(expression) || expression.hasRightParenthesis()) {

        writer.append(RIGHT_PARENTHESIS);

      }

    }

  }

  /**

   * {@inheritDoc}

   */

  public void visit(AbsExpressionStateObject stateObject) {

    toStringSingleEncapsulated(stateObject);

  }

  /**

   * {@inheritDoc}

   */

  public void visit(AbstractSchemaNameStateObject stateObject) {

    toStringSimpleStateObject(stateObject);

  }

  /**

   * {@inheritDoc}

   */

  public void visit(AdditionExpressionStateObject stateObject) {

    toStringCompound(stateObject, PLUS);

  }

  /**

   * {@inheritDoc}

   */

  public void visit(AllOrAnyExpressionStateObject stateObject) {

    toStringSingleEncapsulated(stateObject);

  }

  /**

   * {@inheritDoc}

   */

  public void visit(AndExpressionStateObject stateObject) {

    toStringCompound(stateObject, AND);

  }

  /**

   * {@inheritDoc}

   */

  public void visit(ArithmeticFactorStateObject stateObject) {

    if (stateObject.isDecorated()) {

      toText(stateObject);

    }

    else {

      writer.append(stateObject.getArithmeticSign());

      if (stateObject.hasStateObject()) {

        stateObject.getStateObject().accept(this);

      }

    }

  }

  /**

   * {@inheritDoc}

   */

  public void visit(AvgFunctionStateObject stateObject) {

    toStringAggregateFunction(stateObject);

  }

  /**

   * {@inheritDoc}

   */

  public void visit(BadExpressionStateObject stateObject) {

    toStringSimpleStateObject(stateObject);

  }

  /**

   * {@inheritDoc}

   */

  public void visit(BetweenExpressionStateObject stateObject) {

    if (stateObject.isDecorated()) {

      toText(stateObject);

    }

    else {

      BetweenExpression expression = stateObject.getExpression();

      // Expression

      if (stateObject.hasStateObject()) {

        stateObject.getStateObject().accept(this);

        writer.append(SPACE);

      }

      // 'NOT

      if (stateObject.hasNot()) {

        appendIdentifier((expression != null) ? expression.getActualNotIdentifier() : NOT, NOT);

        writer.append(SPACE);

      }

      // 'BETWEEN'

      appendIdentifier((expression != null) ? expression.getActualBetweenIdentifier() : BETWEEN, BETWEEN);

      if (shouldOutput(expression) || expression.hasSpaceAfterBetween()) {

        writer.append(SPACE);

      }

      // Lower bound expression

      if (stateObject.hasLowerBound()) {

        stateObject.getLowerBound().accept(this);

      }

      if (shouldOutput(expression) || expression.hasSpaceAfterLowerBound()) {

        writer.append(SPACE);

      }

      // 'AND'

      if (shouldOutput(expression) || expression.hasAnd()) {

        appendIdentifier((expression != null) ? expression.getActualAndIdentifier() : AND, AND);

      }

      if (shouldOutput(expression) || expression.hasSpaceAfterAnd()) {

        writer.append(SPACE);

      }

      // Upper bound expression

      if (stateObject.hasUpperBound()) {

        stateObject.getUpperBound().accept(this);

      }

    }

  }

  /**

   * {@inheritDoc}

   */

  public void visit(CaseExpressionStateObject stateObject) {

    if (stateObject.isDecorated()) {

      toText(stateObject);

    }

    else {

      CaseExpression expression = stateObject.getExpression();

      // 'CASE'

      appendIdentifier((expression != null) ? expression.getActualCaseIdentifier() : CASE, CASE);

      if (shouldOutput(expression) || expression.hasSpaceAfterCase()) {

        writer.append(SPACE);

      }

      // Case operand

      if (stateObject.hasCaseOperand()) {

        stateObject.getCaseOperand().accept(this);

        if (shouldOutput(expression) || expression.hasSpaceAfterCaseOperand()) {

          writer.append(SPACE);

        }

      }

      // WHEN clauses

      if (stateObject.hasItems()) {

        toStringChildren(stateObject, false);

      }

      if (shouldOutput(expression) || expression.hasSpaceAfterWhenClauses()) {

        writer.append(SPACE);

      }

      // 'ELSE'

      if (shouldOutput(expression) || expression.hasElse()) {

        appendIdentifier((expression != null) ? expression.getActualElseIdentifier() : ELSE, ELSE);

      }

      if (shouldOutput(expression) || expression.hasSpaceAfterElse()) {

        writer.append(SPACE);

      }

      // Else expression

      if (stateObject.hasElse()) {

        stateObject.getElse().accept(this);

      }

      if (shouldOutput(expression) || expression.hasSpaceAfterElseExpression()) {

        writer.append(SPACE);

      }

      // END

      if (shouldOutput(expression) || expression.hasEnd()) {

        appendIdentifier((expression != null) ? expression.getActualEndIdentifier() : END, END);

      }

    }

  }

  /**

   * {@inheritDoc}

   */

  public void visit(CoalesceExpressionStateObject stateObject) {

    if (stateObject.isDecorated()) {

      toText(stateObject);

    }

    else {

      CoalesceExpression expression = stateObject.getExpression();

      // 'COALESCE'

      appendIdentifier((expression != null) ? expression.getActualIdentifier() : COALESCE, COALESCE);

      // '('

      if (shouldOutput(expression) || expression.hasLeftParenthesis()) {

        writer.append(LEFT_PARENTHESIS);

      }

      else if (expression.hasSpaceAfterIdentifier()) {

        writer.append(SPACE);

      }

      toStringChildren(stateObject, true);

      // ')'

      if (shouldOutput(expression) || expression.hasRightParenthesis()) {

        writer.append(RIGHT_PARENTHESIS);

      }

    }

  }

  /**

   * {@inheritDoc}

   */

  public void visit(CollectionMemberDeclarationStateObject stateObject) {

    if (stateObject.isDecorated()) {

      toText(stateObject);

    }

    else {

      CollectionMemberDeclaration expression = stateObject.getExpression();

      // 'IN'

      appendIdentifier((expression != null) ? expression.getActualInIdentifier() : IN, IN);

      // '('

      if (!stateObject.isDerived() && (shouldOutput(expression) || expression.hasLeftParenthesis())) {

        writer.append(LEFT_PARENTHESIS);

      }

      else if (stateObject.isDerived() && (shouldOutput(expression) || expression.hasSpaceAfterIn())) {

        writer.append(SPACE);

      }

      // Collection-valued path expression

      stateObject.getCollectionValuedPath().accept(this);

      // ')'

      if (!stateObject.isDerived() && (shouldOutput(expression) || expression.hasRightParenthesis())) {

        writer.append(RIGHT_PARENTHESIS);

        if (shouldOutput(expression) || expression.hasSpaceAfterRightParenthesis()) {

          writer.append(SPACE);

        }

      }

      else if (stateObject.isDerived() &&

               stateObject.hasAs() &&

               (shouldOutput(expression) || expression.hasSpaceAfterRightParenthesis())) {

        writer.append(SPACE);

      }