/*
 * Hibernate, Relational Persistence for Idiomatic Java
 *
 * License: GNU Lesser General Public License (LGPL), version 2.1 or later.
 * See the lgpl.txt file in the root directory or <http://www.gnu.org/licenses/lgpl-2.1.html>.
 */
package org.hibernate.hql.internal.classic;

import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.Locale;
import java.util.Map;
import java.util.Set;
import java.util.StringTokenizer;

import org.hibernate.MappingException;
import org.hibernate.QueryException;
import org.hibernate.engine.internal.JoinSequence;
import org.hibernate.hql.spi.QueryTranslator;
import org.hibernate.internal.util.ReflectHelper;
import org.hibernate.internal.util.StringHelper;
import org.hibernate.persister.collection.CollectionPropertyNames;
import org.hibernate.persister.entity.Queryable;
import org.hibernate.sql.InFragment;
import org.hibernate.type.EntityType;
import org.hibernate.type.LiteralType;
import org.hibernate.type.Type;

import static org.hibernate.hql.spi.QueryTranslator.ERROR_LEGACY_ORDINAL_PARAMS_NO_LONGER_SUPPORTED;

Parses the where clause of a hibernate query and translates it to an
SQL where clause.
/**
 * Parses the where clause of a hibernate query and translates it to an
 * SQL where clause.
 */

// We should reengineer this class so that, rather than the current ad -
// hoc linear approach to processing a stream of tokens, we instead
// build up a tree of expressions.

// We would probably refactor to have LogicParser (builds a tree of simple
// expressions connected by and, or, not), ExpressionParser (translates
// from OO terms like foo, foo.Bar, foo.Bar.Baz to SQL terms like
// FOOS.ID, FOOS.BAR_ID, etc) and PathExpressionParser (which does much
// the same thing it does now)

public class WhereParser implements Parser {

	private final PathExpressionParser pathExpressionParser;

	{
		pathExpressionParser = new PathExpressionParser();
		pathExpressionParser.setUseThetaStyleJoin( true ); //Need this, since join condition can appear inside parens!
	}

	private static final Set<String> EXPRESSION_TERMINATORS = new HashSet<String>();   //tokens that close a sub expression
	private static final Set<String> EXPRESSION_OPENERS = new HashSet<String>();       //tokens that open a sub expression
	private static final Set<String> BOOLEAN_OPERATORS = new HashSet<String>();        //tokens that would indicate a sub expression is a boolean expression
	private static final Map<String,String> NEGATIONS = new HashMap<String,String>();

	static {
		EXPRESSION_TERMINATORS.add( "and" );
		EXPRESSION_TERMINATORS.add( "or" );
		EXPRESSION_TERMINATORS.add( ")" );
		//expressionTerminators.add(","); // deliberately excluded

		EXPRESSION_OPENERS.add( "and" );
		EXPRESSION_OPENERS.add( "or" );
		EXPRESSION_OPENERS.add( "(" );
		//expressionOpeners.add(","); // deliberately excluded

		BOOLEAN_OPERATORS.add( "<" );
		BOOLEAN_OPERATORS.add( "=" );
		BOOLEAN_OPERATORS.add( ">" );
		BOOLEAN_OPERATORS.add( "#" );
		BOOLEAN_OPERATORS.add( "~" );
		BOOLEAN_OPERATORS.add( "like" );
		BOOLEAN_OPERATORS.add( "ilike" );
		BOOLEAN_OPERATORS.add( "regexp" );
		BOOLEAN_OPERATORS.add( "rlike" );
		BOOLEAN_OPERATORS.add( "is" );
		BOOLEAN_OPERATORS.add( "in" );
		BOOLEAN_OPERATORS.add( "any" );
		BOOLEAN_OPERATORS.add( "some" );
		BOOLEAN_OPERATORS.add( "all" );
		BOOLEAN_OPERATORS.add( "exists" );
		BOOLEAN_OPERATORS.add( "between" );
		BOOLEAN_OPERATORS.add( "<=" );
		BOOLEAN_OPERATORS.add( ">=" );
		BOOLEAN_OPERATORS.add( "=>" );
		BOOLEAN_OPERATORS.add( "=<" );
		BOOLEAN_OPERATORS.add( "!=" );
		BOOLEAN_OPERATORS.add( "<>" );
		BOOLEAN_OPERATORS.add( "!#" );
		BOOLEAN_OPERATORS.add( "!~" );
		BOOLEAN_OPERATORS.add( "!<" );
		BOOLEAN_OPERATORS.add( "!>" );
		BOOLEAN_OPERATORS.add( "is not" );
		BOOLEAN_OPERATORS.add( "not like" );
		BOOLEAN_OPERATORS.add( "not ilike" );
		BOOLEAN_OPERATORS.add( "not regexp" );
		BOOLEAN_OPERATORS.add( "not rlike" );
		BOOLEAN_OPERATORS.add( "not in" );
		BOOLEAN_OPERATORS.add( "not between" );
		BOOLEAN_OPERATORS.add( "not exists" );

		NEGATIONS.put( "and", "or" );
		NEGATIONS.put( "or", "and" );
		NEGATIONS.put( "<", ">=" );
		NEGATIONS.put( "=", "<>" );
		NEGATIONS.put( ">", "<=" );
		NEGATIONS.put( "#", "!#" );
		NEGATIONS.put( "~", "!~" );
		NEGATIONS.put( "like", "not like" );
		NEGATIONS.put( "ilike", "not ilike" );
		NEGATIONS.put( "regexp", "not regexp" );
		NEGATIONS.put( "rlike", "not rlike" );
		NEGATIONS.put( "is", "is not" );
		NEGATIONS.put( "in", "not in" );
		NEGATIONS.put( "exists", "not exists" );
		NEGATIONS.put( "between", "not between" );
		NEGATIONS.put( "<=", ">" );
		NEGATIONS.put( ">=", "<" );
		NEGATIONS.put( "=>", "<" );
		NEGATIONS.put( "=<", ">" );
		NEGATIONS.put( "!=", "=" );
		NEGATIONS.put( "<>", "=" );
		NEGATIONS.put( "!#", "#" );
		NEGATIONS.put( "!~", "~" );
		NEGATIONS.put( "!<", "<" );
		NEGATIONS.put( "!>", ">" );
		NEGATIONS.put( "is not", "is" );
		NEGATIONS.put( "not like", "like" );
		NEGATIONS.put( "not ilike", "ilike" );
		NEGATIONS.put( "not regexp", "regexp" );
		NEGATIONS.put( "not rlike", "rlike" );
		NEGATIONS.put( "not in", "in" );
		NEGATIONS.put( "not between", "between" );
		NEGATIONS.put( "not exists", "exists" );

	}
	// Handles things like:
	// a and b or c
	// a and ( b or c )
	// not a and not b
	// not ( a and b )
	// x between y and z            (overloaded "and")
	// x in ( a, b, c )             (overloaded brackets)
	// not not a
	// a is not null                (overloaded "not")
	// etc......
	// and expressions like
	// foo = bar                    (maps to: foo.id = bar.id)
	// foo.Bar = 'foo'              (maps to: foo.bar = 'foo')
	// foo.Bar.Baz = 1.0            (maps to: foo.bar = bar.id and bar.baz = 1.0)
	// 1.0 = foo.Bar.Baz            (maps to: bar.baz = 1.0 and foo.Bar = bar.id)
	// foo.Bar.Baz = a.B.C          (maps to: bar.Baz = b.C and foo.Bar = bar.id and a.B = b.id)
	// foo.Bar.Baz + a.B.C          (maps to: bar.Baz + b.C and foo.Bar = bar.id and a.B = b.id)
	// ( foo.Bar.Baz + 1.0 ) < 2.0  (maps to: ( bar.Baz + 1.0 ) < 2.0 and foo.Bar = bar.id)

	private boolean betweenSpecialCase;       //Inside a BETWEEN ... AND ... expression
	private boolean negated;

	private boolean inSubselect;
	private int bracketsSinceSelect;
	private StringBuilder subselect;

	private boolean expectingPathContinuation;
	private int expectingIndex;

	// The following variables are stacks that keep information about each subexpression
	// in the list of nested subexpressions we are currently processing.

	private LinkedList<Boolean> nots = new LinkedList<Boolean>();           //were an odd or even number of NOTs encountered
	private LinkedList<StringBuilder> joins = new LinkedList<StringBuilder>();          //the join string built up by compound paths inside this expression
	private LinkedList<Boolean> booleanTests = new LinkedList<Boolean>();   //a flag indicating if the subexpression is known to be boolean

	private String getElementName(PathExpressionParser.CollectionElement element, QueryTranslatorImpl q) throws QueryException {
		String name;
		if ( element.isOneToMany ) {
			name = element.alias;
		}
		else {
			Type type = element.elementType;
			if ( type.isEntityType() ) { //ie. a many-to-many
				String entityName = ( ( EntityType ) type ).getAssociatedEntityName();
				name = pathExpressionParser.continueFromManyToMany( entityName, element.elementColumns, q );
			}
			else {
				throw new QueryException( "illegally dereferenced collection element" );
			}
		}
		return name;
	}

	public void token(String token, QueryTranslatorImpl q) throws QueryException {
		String lcToken = token.toLowerCase(Locale.ROOT);

		//Cope with [,]
		if ( token.equals( "[" ) && !expectingPathContinuation ) {
			expectingPathContinuation = false;
			if ( expectingIndex == 0 ) {
				throw new QueryException( "unexpected [" );
			}
			return;
		}
		else if ( token.equals( "]" ) ) {
			expectingIndex--;
			expectingPathContinuation = true;
			return;
		}

		//Cope with a continued path expression (ie. ].baz)
		if ( expectingPathContinuation ) {
			boolean pathExpressionContinuesFurther = continuePathExpression( token, q );
			if ( pathExpressionContinuesFurther ) {
				return; //NOTE: early return
			}
		}

		//Cope with a subselect
		if ( !inSubselect && ( lcToken.equals( "select" ) || lcToken.equals( "from" ) ) ) {
			inSubselect = true;
			subselect = new StringBuilder( 20 );
		}
		if ( inSubselect && token.equals( ")" ) ) {
			bracketsSinceSelect--;

			if ( bracketsSinceSelect == -1 ) {
				QueryTranslatorImpl subq = new QueryTranslatorImpl(
						subselect.toString(),
						q.getEnabledFilters(),
						q.getFactory()
				);
				try {
					subq.compile( q );
				}
				catch ( MappingException me ) {
					throw new QueryException( "MappingException occurred compiling subquery", me );
				}
				appendToken( q, subq.getSQLString() );
				inSubselect = false;
				bracketsSinceSelect = 0;
			}
		}
		if ( inSubselect ) {
			if ( token.equals( "(" ) ) {
				bracketsSinceSelect++;
			}
			subselect.append( token ).append( ' ' );
			return;
		}

		//Cope with special cases of AND, NOT, ()
		specialCasesBefore( lcToken );

		//Close extra brackets we opened
		if ( !betweenSpecialCase && EXPRESSION_TERMINATORS.contains( lcToken ) ) {
			closeExpression( q, lcToken );
		}

		//take note when this is a boolean expression
		if ( BOOLEAN_OPERATORS.contains( lcToken ) ) {
			booleanTests.removeLast();
			booleanTests.addLast( Boolean.TRUE );
		}

		if ( lcToken.equals( "not" ) ) {
			nots.addLast(  !(  nots.removeLast() ) );
			negated = !negated;
			return; //NOTE: early return
		}

		//process a token, mapping OO path expressions to SQL expressions
		doToken( token, q );

		//Open any extra brackets we might need.
		if ( !betweenSpecialCase && EXPRESSION_OPENERS.contains( lcToken ) ) {
			openExpression( q, lcToken );
		}

		//Cope with special cases of AND, NOT, )
		specialCasesAfter( lcToken );

	}

	public void start(QueryTranslatorImpl q) throws QueryException {
		token( "(", q );
	}

	public void end(QueryTranslatorImpl q) throws QueryException {
		if ( expectingPathContinuation ) {
			expectingPathContinuation = false;
			PathExpressionParser.CollectionElement element = pathExpressionParser.lastCollectionElement();
			if ( element.elementColumns.length != 1 ) {
				throw new QueryException( "path expression ended in composite collection element" );
			}
			appendToken( q, element.elementColumns[0] );
			addToCurrentJoin( element );
		}
		token( ")", q );
	}

	private void closeExpression(QueryTranslatorImpl q, String lcToken) {
		if ( booleanTests.removeLast() ) { //it was a boolean expression

			if ( booleanTests.size() > 0 ) {
				// the next one up must also be
				booleanTests.removeLast();
				booleanTests.addLast( Boolean.TRUE );
			}

			// Add any joins
			appendToken( q, ( joins.removeLast() ).toString() );

		}
		else {
			StringBuilder join = joins.removeLast();
			joins.getLast().append( join.toString() );
		}

		if ( nots.removeLast() ) {
			negated = !negated;
		}

		if ( !")".equals( lcToken ) ) {
			appendToken( q, ")" );
		}
	}

	private void openExpression(QueryTranslatorImpl q, String lcToken) {
		nots.addLast( Boolean.FALSE );
		booleanTests.addLast( Boolean.FALSE );
		joins.addLast( new StringBuilder() );
		if ( !"(".equals( lcToken ) ) {
			appendToken( q, "(" );
		}
	}

	private void preprocess(String token, QueryTranslatorImpl q) throws QueryException {
		// ugly hack for cases like "elements(foo.bar.collection)"
		// (multi-part path expression ending in elements or indices)
		String[] tokens = StringHelper.split( ".", token, true );
		if (
				tokens.length > 5 &&
				( CollectionPropertyNames.COLLECTION_ELEMENTS.equals( tokens[tokens.length - 1] )
				|| CollectionPropertyNames.COLLECTION_INDICES.equals( tokens[tokens.length - 1] ) )
		) {
			pathExpressionParser.start( q );
			for ( int i = 0; i < tokens.length - 3; i++ ) {
				pathExpressionParser.token( tokens[i], q );
			}
			pathExpressionParser.token( null, q );
			pathExpressionParser.end( q );
			addJoin( pathExpressionParser.getWhereJoin(), q );
			pathExpressionParser.ignoreInitialJoin();
		}
	}

	private void doPathExpression(String token, QueryTranslatorImpl q) throws QueryException {

		preprocess( token, q );

		StringTokenizer tokens = new StringTokenizer( token, ".", true );
		pathExpressionParser.start( q );
		while ( tokens.hasMoreTokens() ) {
			pathExpressionParser.token( tokens.nextToken(), q );
		}
		pathExpressionParser.end( q );
		if ( pathExpressionParser.isCollectionValued() ) {
			openExpression( q, "" );
			appendToken( q, pathExpressionParser.getCollectionSubquery( q.getEnabledFilters() ) );
			closeExpression( q, "" );
			// this is ugly here, but needed because its a subquery
			q.addQuerySpaces( q.getCollectionPersister( pathExpressionParser.getCollectionRole() ).getCollectionSpaces() );
		}
		else {
			if ( pathExpressionParser.isExpectingCollectionIndex() ) {
				expectingIndex++;
			}
			else {
				addJoin( pathExpressionParser.getWhereJoin(), q );
				appendToken( q, pathExpressionParser.getWhereColumn() );
			}
		}
	}

	private void addJoin(JoinSequence joinSequence, QueryTranslatorImpl q) throws QueryException {
		//JoinFragment fromClause = q.createJoinFragment(true);
		//fromClause.addJoins( join.toJoinFragment().toFromFragmentString(), StringHelper.EMPTY_STRING );
		q.addFromJoinOnly( pathExpressionParser.getName(), joinSequence );
		try {
			addToCurrentJoin( joinSequence.toJoinFragment( q.getEnabledFilters(), true ).toWhereFragmentString() );
		}
		catch ( MappingException me ) {
			throw new QueryException( me );
		}
	}

	private void doToken(String token, QueryTranslatorImpl q) throws QueryException {
		if ( q.isName( StringHelper.root( token ) ) ) {
			//path expression
			doPathExpression( q.unalias( token ), q );
		}
		else if ( token.startsWith( ParserHelper.HQL_VARIABLE_PREFIX ) ) {
			//named query parameter
			q.addNamedParameter( token.substring( 1 ) );
			appendToken( q, "?" );
		}
		else if ( token.startsWith( "?" ) ) {
			// ordinal query parameter
			if ( token.length() == 1 ) {
				q.addLegacyPositionalParameter();
				appendToken( q, "?" );
			}
			else {
				final String labelString = token.substring( 1 );
				try {
					final int label = Integer.parseInt( labelString );
					q.addOrdinalParameter( label );
					appendToken( q, "?" );
				}
				catch (NumberFormatException e) {
					throw new QueryException( "Ordinal parameter label must be numeric : " + labelString, e );
				}
			}
		}
		else {
			Queryable persister = q.getEntityPersisterUsingImports( token );
			if ( persister != null ) { // the name of a class
				final String discrim = persister.getDiscriminatorSQLValue();
				if ( InFragment.NULL.equals(discrim) || InFragment.NOT_NULL.equals(discrim) ) {
					throw new QueryException( "subclass test not allowed for null or not null discriminator" );
				}
				else {
					appendToken( q, discrim );
				}
			}
			else {
				Object constant;
				if (
						token.indexOf( '.' ) > -1 &&
						( constant = ReflectHelper.getConstantValue( token, q.getFactory() ) ) != null
				) {
					Type type;
					try {
						type = q.getFactory().getTypeResolver().heuristicType( constant.getClass().getName() );
					}
					catch ( MappingException me ) {
						throw new QueryException( me );
					}
					if ( type == null ) {
						throw new QueryException( QueryTranslator.ERROR_CANNOT_DETERMINE_TYPE + token );
					}
					try {
						//noinspection unchecked
						appendToken( q, ( ( LiteralType ) type ).objectToSQLString( constant, q.getFactory().getDialect() ) );
					}
					catch ( Exception e ) {
						throw new QueryException( QueryTranslator.ERROR_CANNOT_FORMAT_LITERAL + token, e );
					}
				}
				else { //anything else

					String negatedToken = negated ? NEGATIONS.get( token.toLowerCase(Locale.ROOT) ) : null;
					if ( negatedToken != null && ( !betweenSpecialCase || !"or".equals( negatedToken ) ) ) {
						appendToken( q, negatedToken );
					}
					else {
						appendToken( q, token );
					}
				}
			}
		}
	}

	private void addToCurrentJoin(String sql) {
		joins.getLast().append( sql );
	}

	private void addToCurrentJoin(PathExpressionParser.CollectionElement ce)
			throws QueryException {
		try {
			addToCurrentJoin( ce.joinSequence.toJoinFragment().toWhereFragmentString() + ce.indexValue.toString() );
		}
		catch ( MappingException me ) {
			throw new QueryException( me );
		}
	}

	private void specialCasesBefore(String lcToken) {
		if ( lcToken.equals( "between" ) || lcToken.equals( "not between" ) ) {
			betweenSpecialCase = true;
		}
	}

	private void specialCasesAfter(String lcToken) {
		if ( betweenSpecialCase && lcToken.equals( "and" ) ) {
			betweenSpecialCase = false;
		}
	}

	void appendToken(QueryTranslatorImpl q, String token) {
		if ( expectingIndex > 0 ) {
			pathExpressionParser.setLastCollectionElementIndexValue( token );
		}
		else {
			q.appendWhereToken( token );
		}
	}

	private boolean continuePathExpression(String token, QueryTranslatorImpl q) throws QueryException {

		expectingPathContinuation = false;

		PathExpressionParser.CollectionElement element = pathExpressionParser.lastCollectionElement();

		if ( token.startsWith( "." ) ) { // the path expression continues after a ]

			doPathExpression( getElementName( element, q ) + token, q ); // careful with this!

			addToCurrentJoin( element );
			return true; //NOTE: EARLY EXIT!

		}

		else { // the path expression ends at the ]
			if ( element.elementColumns.length != 1 ) {
				throw new QueryException( "path expression ended in composite collection element" );
			}
			appendToken( q, element.elementColumns[0] );
			addToCurrentJoin( element );
			return false;
		}
	}
}