/*
 * Copyright (c) 2011, 2021 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 v. 2.0 which is available at
 * http://www.eclipse.org/legal/epl-2.0,
 * or the Eclipse Distribution License v. 1.0 which is available at
 * http://www.eclipse.org/org/documents/edl-v10.php.
 *
 * SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
 */

// Contributors:
//     Oracle - initial API and implementation
//
package org.eclipse.persistence.internal.jpa.jpql;

import java.util.Collection;
import java.util.Collections;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Set;

import org.eclipse.persistence.jpa.jpql.ExpressionTools;
import org.eclipse.persistence.jpa.jpql.JPQLQueryDeclaration.Type;
import org.eclipse.persistence.jpa.jpql.LiteralType;
import org.eclipse.persistence.jpa.jpql.parser.AbstractEclipseLinkExpressionVisitor;
import org.eclipse.persistence.jpa.jpql.parser.AbstractSchemaName;
import org.eclipse.persistence.jpa.jpql.parser.CollectionExpression;
import org.eclipse.persistence.jpa.jpql.parser.CollectionMemberDeclaration;
import org.eclipse.persistence.jpa.jpql.parser.CollectionValuedPathExpression;
import org.eclipse.persistence.jpa.jpql.parser.DeleteClause;
import org.eclipse.persistence.jpa.jpql.parser.DeleteStatement;
import org.eclipse.persistence.jpa.jpql.parser.Expression;
import org.eclipse.persistence.jpa.jpql.parser.FromClause;
import org.eclipse.persistence.jpa.jpql.parser.IdentificationVariable;
import org.eclipse.persistence.jpa.jpql.parser.IdentificationVariableDeclaration;
import org.eclipse.persistence.jpa.jpql.parser.JPQLExpression;
import org.eclipse.persistence.jpa.jpql.parser.Join;
import org.eclipse.persistence.jpa.jpql.parser.RangeVariableDeclaration;
import org.eclipse.persistence.jpa.jpql.parser.ResultVariable;
import org.eclipse.persistence.jpa.jpql.parser.SelectClause;
import org.eclipse.persistence.jpa.jpql.parser.SelectStatement;
import org.eclipse.persistence.jpa.jpql.parser.SimpleFromClause;
import org.eclipse.persistence.jpa.jpql.parser.SimpleSelectClause;
import org.eclipse.persistence.jpa.jpql.parser.SimpleSelectStatement;
import org.eclipse.persistence.jpa.jpql.parser.SubExpression;
import org.eclipse.persistence.jpa.jpql.parser.TableVariableDeclaration;
import org.eclipse.persistence.jpa.jpql.parser.UpdateClause;
import org.eclipse.persistence.jpa.jpql.parser.UpdateStatement;

/**
 * This visitor visits the declaration clause of the JPQL query and creates the list of
 * {@link Declaration Declarations}.
 *
 * @version 2.5
 * @since 2.4
 * @author Pascal Filion
 */
@SuppressWarnings("nls")
final class DeclarationResolver {

    /**
     * The first {@link Declaration} that was created when visiting the declaration clause.
     */
    private Declaration baseDeclaration;

    /**
     * The {@link Declaration} objects mapped to their identification variable.
     */
    private List<Declaration> declarations;

    /**
     * The parent {@link DeclarationResolver} which represents the superquery's declaration or
     * <code>null</code> if this is used for the top-level query.
     */
    private DeclarationResolver parent;

    /**
     * Determines whether the {@link Declaration Declaration} objects were created after visiting the
     * query's declaration clause.
     */
    private boolean populated;

    /**
     * The {@link JPQLQueryContext} is used to query information about the application metadata and
     * cached information.
     */
    private JPQLQueryContext queryContext;

    /**
     * The result variables used to identify select expressions.
     */
    private Collection<IdentificationVariable> resultVariables;

    /**
     * Creates a new <code>DeclarationResolver</code>.
     *
     * @param queryContext The context used to query information about the application metadata and
     * cached information
     * @param parent The parent {@link DeclarationResolver} which represents the superquery's declaration
     */
    DeclarationResolver(JPQLQueryContext queryContext, DeclarationResolver parent) {
        super();
        initialize(queryContext, parent);
    }

    /**
     * Adds a "virtual" range variable declaration that will be used when parsing a JPQL fragment.
     *
     * @param entityName The name of the entity to be accessible with the given variable name
     * @param variableName The identification variable used to navigate to the entity
     */
    void addRangeVariableDeclaration(String entityName, String variableName) {

        // This method should only be used by HermesParser.buildSelectionCriteria(),
        // initializes these variables right away since this method should only be
        // called by HermesParser.buildSelectionCriteria()
        populated = true;
        resultVariables = Collections.emptySet();

        // Create the "virtual" range variable declaration
        RangeVariableDeclaration rangeVariableDeclaration = new RangeVariableDeclaration(
            entityName,
            variableName
        );

        // Make sure the identification variable was not declared more than once,
        // this could cause issues when trying to resolve it
        RangeDeclaration declaration = new RangeDeclaration(queryContext);
        declaration.rootPath               = entityName;
        declaration.baseExpression         = rangeVariableDeclaration;
        declaration.identificationVariable = (IdentificationVariable) rangeVariableDeclaration.getIdentificationVariable();

        declarations.add(declaration);

        // Make sure it is marked as the base declaration and the base Expression is created
        if (baseDeclaration == null) {
            baseDeclaration = declaration;

            // Make sure the base Expression is initialized, which will cache it
            // into the right context as well (the top-level context)
            declaration.getQueryExpression();
        }
    }

    /**
     * Converts the given {@link Declaration} from being set as a range variable declaration to
     * a path expression declaration.
     * <p>
     * In this query "{@code UPDATE Employee SET firstName = 'MODIFIED' WHERE (SELECT COUNT(m) FROM
     * managedEmployees m) > 0}" <em>managedEmployees</em> is an unqualified collection-valued
     * path expression (<code>employee.managedEmployees</code>).
     *
     * @param declaration The {@link Declaration} that was parsed to range over an abstract schema
     * name but is actually ranging over a path expression
     * @param outerVariableName The identification variable coming from the parent identification
     * variable declaration
     */
    void convertUnqualifiedDeclaration(RangeDeclaration declaration, String outerVariableName) {

        QualifyRangeDeclarationVisitor visitor = new QualifyRangeDeclarationVisitor();

        // Convert the declaration expression into a derived declaration
        visitor.declaration       = declaration;
        visitor.outerVariableName = outerVariableName;
        visitor.queryContext      = queryContext.getCurrentContext();

        declaration.declarationExpression.accept(visitor);

        // Now replace the old declaration with the new one
        int index = declarations.indexOf(declaration);
        declarations.set(index, visitor.declaration);

        // Update the base declaration
        if (baseDeclaration == declaration) {
            baseDeclaration = visitor.declaration;
        }
    }

    /**
     * Retrieves the {@link Declaration} for which the given variable name is used to navigate to the
     * "root" object.
     *
     * @param variableName The name of the identification variable that is used to navigate a "root"
     * object
     * @return The {@link Declaration} containing the information about the identification variable
     * declaration
     */
    Declaration getDeclaration(String variableName) {

        for (Declaration declaration : declarations) {
            if (declaration.getVariableName().equalsIgnoreCase(variableName)) {
                return declaration;
            }
        }

        return null;
    }

    /**
     * Returns the ordered list of {@link Declaration Declarations}.
     *
     * @return The {@link Declaration Declarations} of the current query that was parsed
     */
    List<Declaration> getDeclarations() {
        return declarations;
    }

    /**
     * Returns the first {@link Declaration} that was created after visiting the declaration clause.
     *
     * @return The first {@link Declaration} object
     */
    Declaration getFirstDeclaration() {
        return baseDeclaration;
    }

    /**
     * Returns the parsed representation of a <b>JOIN FETCH</b> that were defined in the same
     * declaration than the given range identification variable name.
     *
     * @param variableName The name of the identification variable that should be used to define an entity
     * @return The <b>JOIN FETCH</b> expressions used in the same declaration or an empty collection
     * if none was defined
     */
    Collection<Join> getJoinFetches(String variableName) {

        Declaration declaration = getDeclaration(variableName);

        if ((declaration != null) && (declaration.getType() == Type.RANGE)) {
            RangeDeclaration rangeDeclaration = (RangeDeclaration) declaration;
            if (rangeDeclaration.hasJoins()) {
                return rangeDeclaration.getJoinFetches();
            }
        }

        return null;
    }

    /**
     * Returns the parent of this {@link DeclarationResolver}.
     *
     * @return The parent of this {@link DeclarationResolver} if this is used for a subquery or
     * <code>null</code> if this is used for the top-level query
     */
    DeclarationResolver getParent() {
        return parent;
    }

    /**
     * Returns the variables that got defined in the select expression. This only applies to JPQL
     * queries built for JPA 2.0 or later.
     *
     * @return The variables identifying the select expressions, if any was defined or an empty set
     * if none were defined
     */
    Collection<IdentificationVariable> getResultVariables() {

        if (parent != null) {
            return parent.getResultVariables();
        }

        if (resultVariables == null) {
            ResultVariableVisitor visitor = new ResultVariableVisitor();
            queryContext.getJPQLExpression().accept(visitor);
            resultVariables = visitor.resultVariables;
        }

        return resultVariables;
    }

    /**
     * Initializes this <code>DeclarationResolver</code>.
     *
     * @param queryContext The context used to query information about the query
     * @param parent The parent {@link DeclarationResolver}, which is not <code>null</code> when this
     * resolver is created for a subquery
     */
    private void initialize(JPQLQueryContext queryContext, DeclarationResolver parent) {
        this.parent       = parent;
        this.queryContext = queryContext;
        this.declarations = new LinkedList<>();
    }

    /**
     * Determines whether the given identification variable is defining a <b>JOIN</b> expression or
     * in a <code>IN</code> expressions for a collection-valued field. If the search didn't find the
     * identification in this resolver, then it will traverse the parent hierarchy.
     *
     * @param variableName The identification variable to check for what it maps
     * @return <code>true</code> if the given identification variable maps a collection-valued field
     * defined in a <code>JOIN</code> or <code>IN</code> expression; <code>false</code> otherwise
     */
    boolean isCollectionIdentificationVariable(String variableName) {

        boolean result = isCollectionIdentificationVariableImp(variableName);

        if (!result && (parent != null)) {
            result = parent.isCollectionIdentificationVariableImp(variableName);
        }

        return result;
    }

    /**
     * Determines whether the given identification variable is defining a <b>JOIN</b> expression or
     * in a <code>IN</code> expressions for a collection-valued field. The search does not traverse
     * the parent hierarchy.
     *
     * @param variableName The identification variable to check for what it maps
     * @return <code>true</code> if the given identification variable maps a collection-valued field
     * defined in a <code>JOIN</code> or <code>IN</code> expression; <code>false</code> otherwise
     */
    @SuppressWarnings({"fallthrough"})
    boolean isCollectionIdentificationVariableImp(String variableName) {

        for (Declaration declaration : declarations) {

            switch (declaration.getType()) {

                case COLLECTION: {
                    if (declaration.getVariableName().equalsIgnoreCase(variableName)) {
                        return true;
                    }
                    return false;
                }

                case RANGE:
                case DERIVED: {

                    AbstractRangeDeclaration rangeDeclaration = (AbstractRangeDeclaration) declaration;

                    // Check the JOIN expressions
                    for (Join join : rangeDeclaration.getJoins()) {

                        String joinVariableName = queryContext.literal(
                            join.getIdentificationVariable(),
                            LiteralType.IDENTIFICATION_VARIABLE
                        );

                        if (joinVariableName.equalsIgnoreCase(variableName)) {
                            // Make sure the JOIN expression maps a collection mapping
                            Declaration joinDeclaration = queryContext.getDeclaration(joinVariableName);
                            return joinDeclaration.getMapping().isCollectionMapping();
                        }
                    }
                }
                default:
                    continue;
            }
        }

        return false;
    }

    /**
     * Determines whether the given variable name is an identification variable name used to define
     * an abstract schema name.
     *
     * @param variableName The name of the variable to verify if it's defined in a range variable
     * declaration in the current query or any parent query
     * @return <code>true</code> if the variable name is mapping an abstract schema name; <code>false</code>
     * if it's defined in a collection member declaration
     */
    boolean isRangeIdentificationVariable(String variableName) {
        boolean result = isRangeIdentificationVariableImp(variableName);
        if (!result && (parent != null)) {
            result = parent.isRangeIdentificationVariableImp(variableName);
        }
        return result;
    }

    private boolean isRangeIdentificationVariableImp(String variableName) {
        Declaration declaration = getDeclaration(variableName);
        return (declaration != null) && declaration.getType().isRange();
    }

    /**
     * Determines whether the given variable is a result variable or not.
     *
     * @param variableName The variable to check if it used to identify a select expression
     * @return <code>true</code> if the given variable is defined as a result variable;
     * <code>false</code> otherwise
     */
    boolean isResultVariable(String variableName) {

        // Only the top-level SELECT query has result variables
        if (parent != null) {
            return parent.isResultVariable(variableName);
        }

        for (IdentificationVariable resultVariable : getResultVariables()) {
            if (resultVariable.getText().equalsIgnoreCase(variableName)) {
                return true;
            }
        }

        return false;
    }

    /**
     * Visits the given {@link Expression} (which is either the top-level query or a subquery) and
     * retrieve the information from its declaration clause.
     *
     * @param expression The {@link Expression} to visit in order to retrieve the information
     * contained in the given query's declaration
     */
    void populate(Expression expression) {
        if (!populated) {
            populated = true;
            populateImp(expression);
        }
    }

    private void populateImp(Expression expression) {

        DeclarationVisitor visitor = new DeclarationVisitor();
        visitor.queryContext = queryContext;
        visitor.declarations = declarations;

        expression.accept(visitor);
        baseDeclaration = visitor.baseDeclaration;
    }

    private static class DeclarationVisitor extends AbstractEclipseLinkExpressionVisitor {

        /**
         * The first {@link Declaration} that was created when visiting the declaration clause.
         */
        private Declaration baseDeclaration;

        /**
         * This flag is used to determine what to do in {@link #visit(SimpleSelectStatement)}.
         */
        private boolean buildingDeclaration;

        /**
         * The {@link Declaration} being populated.
         */
        private Declaration currentDeclaration;

        /**
         * The list of {@link Declaration} objects to which new ones will be added by traversing the
         * declaration clause.
         */
        List<Declaration> declarations;

        /**
         * The {@link JPQLQueryContext} is used to query information about the application metadata and
         * cached information.
         */
        JPQLQueryContext queryContext;

        @Override
        public void visit(AbstractSchemaName expression) {

            String rootPath = expression.getText();

            // Abstract schema name (entity name)
            if (rootPath.indexOf('.') == -1) {
                currentDeclaration = new RangeDeclaration(queryContext);
            }
            else {

                // Check to see if the "root" path is a class name before assuming it's a derived path
                Class<?> type = queryContext.getType(rootPath);

                // Fully qualified class name
                if (type != null) {
                    RangeDeclaration declaration = new RangeDeclaration(queryContext);
                    declaration.type = type;
                    currentDeclaration = declaration;
                }
                // Derived path expression (for subqueries)
                else {
                    currentDeclaration = new DerivedDeclaration(queryContext);
                }
            }

            currentDeclaration.rootPath = rootPath;
        }

        @Override
        public void visit(CollectionExpression expression) {
            expression.acceptChildren(this);
        }

        @Override
        public void visit(CollectionMemberDeclaration expression) {

            Declaration declaration = new CollectionDeclaration(queryContext);
            declaration.baseExpression        = expression.getCollectionValuedPathExpression();
            declaration.rootPath              = declaration.baseExpression.toActualText();
            declaration.declarationExpression = expression;
            declarations.add(declaration);

            // A derived collection member declaration does not have an identification variable
            if (!expression.isDerived()) {
                IdentificationVariable identificationVariable = (IdentificationVariable) expression.getIdentificationVariable();
                declaration.identificationVariable = identificationVariable;
            }

            // This collection member declaration is the first defined,
            // it is then the base Declaration
            if (baseDeclaration == null) {
                baseDeclaration = declaration;
            }
        }

        @Override
        public void visit(CollectionValuedPathExpression expression) {

            String rootPath = expression.toParsedText();

            // Check to see if the "root" path is a class name before assuming it's a derived path
            Class<?> type = queryContext.getType(rootPath);

            // Fully qualified class name
            if (type != null) {
                RangeDeclaration declaration = new RangeDeclaration(queryContext);
                declaration.type = type;
                currentDeclaration = declaration;
            }
            // Derived path expression (for subqueries)
            else {
                currentDeclaration = new DerivedDeclaration(queryContext);
            }

            currentDeclaration.rootPath = rootPath;
        }

        @Override
        public void visit(DeleteClause expression) {
            try {
                expression.getRangeVariableDeclaration().accept(this);
            }
            finally {
                currentDeclaration = null;
            }
        }

        @Override
        public void visit(DeleteStatement expression) {
            expression.getDeleteClause().accept(this);
        }

        @Override
        public void visit(FromClause expression) {
            expression.getDeclaration().accept(this);
        }

        @Override
        public void visit(IdentificationVariableDeclaration expression) {

            try {
                // Visit the RangeVariableDeclaration, it will create the right Declaration
                expression.getRangeVariableDeclaration().accept(this);
                currentDeclaration.declarationExpression = expression;

                // Now visit the JOIN expressions
                expression.getJoins().accept(this);
            }
            finally {
                currentDeclaration = null;
            }
        }

        @Override
        public void visit(Join expression) {

            ((AbstractRangeDeclaration) currentDeclaration).addJoin(expression);

            if (!expression.hasFetch() || expression.hasIdentificationVariable()) {
                IdentificationVariable identificationVariable = (IdentificationVariable) expression.getIdentificationVariable();

                JoinDeclaration declaration = new JoinDeclaration(queryContext);
                declaration.baseExpression = expression;
                declaration.identificationVariable = identificationVariable;
                declarations.add(declaration);
            }
        }

        @Override
        public void visit(JPQLExpression expression) {
            expression.getQueryStatement().accept(this);
        }

        @Override
        public void visit(RangeVariableDeclaration expression) {

            // Traverse the "root" object, it will create the right Declaration
            buildingDeclaration = true;
            expression.getRootObject().accept(this);
            buildingDeclaration = false;

            // Cache more information
            currentDeclaration.identificationVariable = (IdentificationVariable) expression.getIdentificationVariable();
            currentDeclaration.baseExpression = expression;
            declarations.add(currentDeclaration);

            // This range variable declaration is the first defined,
            // it is then the base declaration
            if (baseDeclaration == null) {
                baseDeclaration = currentDeclaration;
            }
        }

        @Override
        public void visit(SelectStatement expression) {
            expression.getFromClause().accept(this);
        }

        @Override
        public void visit(SimpleFromClause expression) {
            expression.getDeclaration().accept(this);
        }

        @Override
        public void visit(SimpleSelectClause expression) {
            expression.getSelectExpression().accept(this);
        }

        @Override
        public void visit(SimpleSelectStatement expression) {

            // The parent query is using a subquery in the FROM clause
            if (buildingDeclaration) {
                currentDeclaration = new SubqueryDeclaration(queryContext);
                currentDeclaration.rootPath = ExpressionTools.EMPTY_STRING;
            }
            // Simply traversing the tree to create the declarations
            else {
                expression.getFromClause().accept(this);
            }
        }

        @Override
        public void visit(SubExpression expression) {
            expression.getExpression().accept(this);
        }

        @Override
        public void visit(TableVariableDeclaration expression) {

            TableDeclaration declaration = new TableDeclaration(queryContext);
            declaration.declarationExpression  = expression;
            declaration.baseExpression         = expression.getTableExpression();
            declaration.rootPath               = declaration.baseExpression.toParsedText();
            declaration.identificationVariable = (IdentificationVariable) expression.getIdentificationVariable();
            declarations.add(declaration);
        }

        @Override
        public void visit(UpdateClause expression) {
            try {
                expression.getRangeVariableDeclaration().accept(this);
            }
            finally {
                currentDeclaration = null;
            }
        }

        @Override
        public void visit(UpdateStatement expression) {
            expression.getUpdateClause().accept(this);
        }
    }

    private static class QualifyRangeDeclarationVisitor extends AbstractEclipseLinkExpressionVisitor {

        /**
         * The {@link Declaration} being modified.
         */
        AbstractRangeDeclaration declaration;

        /**
         * The identification variable coming from the parent identification variable declaration.
         */
        String outerVariableName;

        /**
         * The {@link JPQLQueryContext} is used to query information about the application metadata and
         * cached information.
         */
        JPQLQueryContext queryContext;

        @Override
        public void visit(CollectionValuedPathExpression expression) {
            // Create the path because CollectionValuedPathExpression.toParsedText()
            // does not contain the virtual identification variable
            StringBuilder rootPath = new StringBuilder();
            rootPath.append(outerVariableName);
            rootPath.append(".");
            rootPath.append(expression.toParsedText());
            declaration.rootPath = rootPath.toString();
        }

        @Override
        public void visit(IdentificationVariableDeclaration expression) {
            expression.getRangeVariableDeclaration().accept(this);
            declaration.declarationExpression = expression;
        }

        @Override
        public void visit(RangeVariableDeclaration expression) {

            DerivedDeclaration derivedDeclaration = new DerivedDeclaration(queryContext);
            derivedDeclaration.joins                       = declaration.joins;
            derivedDeclaration.rootPath                    = declaration.rootPath;
            derivedDeclaration.baseExpression              = declaration.baseExpression;
            derivedDeclaration.identificationVariable      = declaration.identificationVariable;
            declaration = derivedDeclaration;

            expression.setVirtualIdentificationVariable(outerVariableName, declaration.rootPath);
            expression.getRootObject().accept(this);
        }
    }

    /**
     * This visitor traverses the <code><b>SELECT</b></code> clause and retrieves the result variables.
     */
    private static class ResultVariableVisitor extends AbstractEclipseLinkExpressionVisitor {

        Set<IdentificationVariable> resultVariables;

        /**
         * Creates a new <code>ResultVariableVisitor</code>.
         */
        public ResultVariableVisitor() {
            super();
            resultVariables = new HashSet<>();
        }

        @Override
        public void visit(CollectionExpression expression) {
            expression.acceptChildren(this);
        }

        @Override
        public void visit(JPQLExpression expression) {
            expression.getQueryStatement().accept(this);
        }

        @Override
        public void visit(ResultVariable expression) {
            IdentificationVariable identificationVariable = (IdentificationVariable) expression.getResultVariable();
            resultVariables.add(identificationVariable);
        }

        @Override
        public void visit(SelectClause expression) {
            expression.getSelectExpression().accept(this);
        }

        @Override
        public void visit(SelectStatement expression) {
            expression.getSelectClause().accept(this);
        }
    }
}