/*
 * 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.LinkedList;
import java.util.Map;

import org.hibernate.MappingException;
import org.hibernate.QueryException;
import org.hibernate.engine.internal.JoinSequence;
import org.hibernate.hql.internal.CollectionSubqueryFactory;
import org.hibernate.persister.collection.CollectionPropertyMapping;
import org.hibernate.persister.collection.QueryableCollection;
import org.hibernate.persister.entity.EntityPersister;
import org.hibernate.persister.entity.PropertyMapping;
import org.hibernate.persister.entity.Queryable;
import org.hibernate.sql.JoinType;
import org.hibernate.type.AssociationType;
import org.hibernate.type.CollectionType;
import org.hibernate.type.EntityType;
import org.hibernate.type.Type;

Parses an expression of the form foo.bar.baz and builds up an expression
involving two less table joins than there are path components.
/**
 * Parses an expression of the form foo.bar.baz and builds up an expression
 * involving two less table joins than there are path components.
 */
public class PathExpressionParser implements Parser {

	//TODO: this class does too many things! we need a different
	//kind of path expression parser for each of the diffferent
	//ways in which path expressions can occur

	//We should actually rework this class to not implement Parser
	//and just process path expressions in the most convenient way.

	//The class is now way to complex!

	private int dotcount;
	private String currentName;
	private String currentProperty;
	private String oneToOneOwnerName;
	private AssociationType ownerAssociationType;
	private String[] columns;
	private String collectionName;
	private String collectionOwnerName;
	private String collectionRole;
	private final StringBuilder componentPath = new StringBuilder();
	private Type type;
	private final StringBuilder path = new StringBuilder();
	private boolean ignoreInitialJoin;
	private boolean continuation;
	private JoinType joinType = JoinType.INNER_JOIN; //default mode
	private boolean useThetaStyleJoin = true;
	private PropertyMapping currentPropertyMapping;
	private JoinSequence joinSequence;

	private boolean expectingCollectionIndex;
	private LinkedList collectionElements = new LinkedList();

	void setJoinType(JoinType joinType) {
		this.joinType = joinType;
	}

	void setUseThetaStyleJoin(boolean useThetaStyleJoin) {
		this.useThetaStyleJoin = useThetaStyleJoin;
	}

	private void addJoin(String name, AssociationType joinableType) throws QueryException {
		try {
			joinSequence.addJoin( joinableType, name, joinType, currentColumns() );
		}
		catch ( MappingException me ) {
			throw new QueryException( me );
		}
	}

	private void addJoin(String name, AssociationType joinableType, String[] foreignKeyColumns) throws QueryException {
		try {
			joinSequence.addJoin( joinableType, name, joinType, foreignKeyColumns );
		}
		catch ( MappingException me ) {
			throw new QueryException( me );
		}
	}

	String continueFromManyToMany(String entityName, String[] joinColumns, QueryTranslatorImpl q) throws QueryException {
		start( q );
		continuation = true;
		currentName = q.createNameFor( entityName );
		q.addType( currentName, entityName );
		Queryable classPersister = q.getEntityPersister( entityName );
		//QueryJoinFragment join = q.createJoinFragment(useThetaStyleJoin);
		addJoin( currentName, q.getFactory().getTypeResolver().getTypeFactory().manyToOne( entityName ), joinColumns );
		currentPropertyMapping = classPersister;
		return currentName;
	}

	public void ignoreInitialJoin() {
		ignoreInitialJoin = true;
	}

	public void token(String token, QueryTranslatorImpl q) throws QueryException {

		if ( token != null ) {
			path.append( token );
		}

		String alias = q.getPathAlias( path.toString() );
		if ( alias != null ) {
			reset( q ); //reset the dotcount (but not the path)
			currentName = alias; //after reset!
			currentPropertyMapping = q.getPropertyMapping( currentName );
			if ( !ignoreInitialJoin ) {
				JoinSequence ojf = q.getPathJoin( path.toString() );
				try {
					joinSequence.addCondition( ojf.toJoinFragment( q.getEnabledFilters(), true ).toWhereFragmentString() ); //after reset!
				}
				catch ( MappingException me ) {
					throw new QueryException( me );
				}
				// we don't need to worry about any condition in the ON clause
				// here (toFromFragmentString), since anything in the ON condition
				// is already applied to the whole query
			}
		}
		else if ( ".".equals( token ) ) {
			dotcount++;
		}
		else {
			if ( dotcount == 0 ) {
				if ( !continuation ) {
					if ( !q.isName( token ) ) {
						throw new QueryException( "undefined alias: " + token );
					}
					currentName = token;
					currentPropertyMapping = q.getPropertyMapping( currentName );
				}
			}
			else if ( dotcount == 1 ) {
				if ( currentName != null ) {
					currentProperty = token;
				}
				else if ( collectionName != null ) {
					//processCollectionProperty(token, q.getCollectionPersister(collectionRole), collectionName);
					continuation = false;
				}
				else {
					throw new QueryException( "unexpected" );
				}
			}
			else { // dotcount>=2

				// Do the corresponding RHS
				Type propertyType = getPropertyType();

				if ( propertyType == null ) {
					throw new QueryException( "unresolved property: " + path );
				}

				if ( propertyType.isComponentType() ) {
					dereferenceComponent( token );
				}
				else if ( propertyType.isEntityType() ) {
					if ( !isCollectionValued() ) {
						dereferenceEntity( token, ( EntityType ) propertyType, q );
					}
				}
				else if ( propertyType.isCollectionType() ) {
					dereferenceCollection( token, ( ( CollectionType ) propertyType ).getRole(), q );

				}
				else {
					if ( token != null ) {
						throw new QueryException( "dereferenced: " + path );
					}
				}

			}
		}
	}

	private void dereferenceEntity(String propertyName, EntityType propertyType, QueryTranslatorImpl q)
			throws QueryException {
		//NOTE: we avoid joining to the next table if the named property is just the foreign key value

		//if its "id"
		boolean isIdShortcut = EntityPersister.ENTITY_ID.equals( propertyName )
				&& propertyType.isReferenceToPrimaryKey();

		//or its the id property name
		final String idPropertyName;
		try {
			idPropertyName = propertyType.getIdentifierOrUniqueKeyPropertyName( q.getFactory() );
		}
		catch ( MappingException me ) {
			throw new QueryException( me );
		}
		boolean isNamedIdPropertyShortcut = idPropertyName != null
				&& idPropertyName.equals( propertyName )
				&& propertyType.isReferenceToPrimaryKey();


		if ( isIdShortcut || isNamedIdPropertyShortcut ) {
			// special shortcut for id properties, skip the join!
			// this must only occur at the _end_ of a path expression
			if ( componentPath.length() > 0 ) {
				componentPath.append( '.' );
			}
			componentPath.append( propertyName );
		}
		else {
			String entityClass = propertyType.getAssociatedEntityName();
			String name = q.createNameFor( entityClass );
			q.addType( name, entityClass );
			addJoin( name, propertyType );
			if ( propertyType.isOneToOne() ) {
				oneToOneOwnerName = currentName;
			}
			ownerAssociationType = propertyType;
			currentName = name;
			currentProperty = propertyName;
			q.addPathAliasAndJoin( path.substring( 0, path.toString().lastIndexOf( '.' ) ), name, joinSequence.copy() );
			componentPath.setLength( 0 );
			currentPropertyMapping = q.getEntityPersister( entityClass );
		}
	}

	private void dereferenceComponent(String propertyName) {
		if ( propertyName != null ) {
			if ( componentPath.length() > 0 ) {
				componentPath.append( '.' );
			}
			componentPath.append( propertyName );
		}
	}

	private void dereferenceCollection(String propertyName, String role, QueryTranslatorImpl q) throws QueryException {
		collectionRole = role;
		QueryableCollection collPersister = q.getCollectionPersister( role );
		String name = q.createNameForCollection( role );
		addJoin( name, collPersister.getCollectionType() );
		//if ( collPersister.hasWhere() ) join.addCondition( collPersister.getSQLWhereString(name) );
		collectionName = name;
		collectionOwnerName = currentName;
		currentName = name;
		currentProperty = propertyName;
		componentPath.setLength( 0 );
		currentPropertyMapping = new CollectionPropertyMapping( collPersister );
	}

	private String getPropertyPath() {
		if ( currentProperty == null ) {
			return EntityPersister.ENTITY_ID;
		}
		else {
			if ( componentPath.length() > 0 ) {
				return currentProperty + '.' + componentPath.toString();
			}
			else {
				return currentProperty;
			}
		}
	}

	private PropertyMapping getPropertyMapping() {
		return currentPropertyMapping;
	}

	private void setType() throws QueryException {
		if ( currentProperty == null ) {
			type = getPropertyMapping().getType();
		}
		else {
			type = getPropertyType();
		}
	}

	protected Type getPropertyType() throws QueryException {
		String propertyPath = getPropertyPath();
		Type propertyType = getPropertyMapping().toType( propertyPath );
		if ( propertyType == null ) {
			throw new QueryException( "could not resolve property type: " + propertyPath );
		}
		return propertyType;
	}

	protected String[] currentColumns() throws QueryException {
		String propertyPath = getPropertyPath();
		String[] propertyColumns = getPropertyMapping().toColumns( currentName, propertyPath );
		if ( propertyColumns == null ) {
			throw new QueryException( "could not resolve property columns: " + propertyPath );
		}
		return propertyColumns;
	}

	private void reset(QueryTranslatorImpl q) {
		//join = q.createJoinFragment(useThetaStyleJoin);
		dotcount = 0;
		currentName = null;
		currentProperty = null;
		collectionName = null;
		collectionRole = null;
		componentPath.setLength( 0 );
		type = null;
		collectionName = null;
		columns = null;
		expectingCollectionIndex = false;
		continuation = false;
		currentPropertyMapping = null;
	}

	public void start(QueryTranslatorImpl q) {
		if ( !continuation ) {
			reset( q );
			path.setLength( 0 );
			joinSequence = new JoinSequence( q.getFactory() ).setUseThetaStyle( useThetaStyleJoin );
		}
	}

	public void end(QueryTranslatorImpl q) throws QueryException {
		ignoreInitialJoin = false;

		Type propertyType = getPropertyType();
		if ( propertyType != null && propertyType.isCollectionType() ) {
			collectionRole = ( ( CollectionType ) propertyType ).getRole();
			collectionName = q.createNameForCollection( collectionRole );
			prepareForIndex( q );
		}
		else {
			columns = currentColumns();
			setType();
		}

		//important!!
		continuation = false;

	}

	private void prepareForIndex(QueryTranslatorImpl q) throws QueryException {

		QueryableCollection collPersister = q.getCollectionPersister( collectionRole );

		if ( !collPersister.hasIndex() ) {
			throw new QueryException( "unindexed collection before []: " + path );
		}

		String[] indexCols = collPersister.getIndexColumnNames();
		if ( indexCols.length != 1 ) {
			throw new QueryException( "composite-index appears in []: " + path );
		}
		//String[] keyCols = collPersister.getKeyColumnNames();

		JoinSequence fromJoins = new JoinSequence( q.getFactory() )
				.setUseThetaStyle( useThetaStyleJoin )
				.setRoot( collPersister, collectionName )
				.setNext( joinSequence.copy() );

		if ( !continuation ) {
			addJoin( collectionName, collPersister.getCollectionType() );
		}

		joinSequence.addCondition( collectionName + '.' + indexCols[0] + " = " ); //TODO: get SQL rendering out of here

		CollectionElement elem = new CollectionElement();
		elem.elementColumns = collPersister.getElementColumnNames(collectionName);
		elem.elementType = collPersister.getElementType();
		elem.isOneToMany = collPersister.isOneToMany();
		elem.alias = collectionName;
		elem.joinSequence = joinSequence;
		collectionElements.addLast( elem );
		setExpectingCollectionIndex();

		q.addCollection( collectionName, collectionRole );
		q.addFromJoinOnly( collectionName, fromJoins );
	}

	static final class CollectionElement {
		Type elementType;
		boolean isOneToMany;
		String alias;
		String[] elementColumns;
		JoinSequence joinSequence;
		StringBuilder indexValue = new StringBuilder();
	}

	public CollectionElement lastCollectionElement() {
		return ( CollectionElement ) collectionElements.removeLast();
	}

	public void setLastCollectionElementIndexValue(String value) {
		( ( CollectionElement ) collectionElements.getLast() ).indexValue.append( value );
	}

	public boolean isExpectingCollectionIndex() {
		return expectingCollectionIndex;
	}

	protected void setExpectingCollectionIndex() throws QueryException {
		expectingCollectionIndex = true;
	}

	public JoinSequence getWhereJoin() {
		return joinSequence;
	}

	public String getWhereColumn() throws QueryException {
		if ( columns.length != 1 ) {
			throw new QueryException( "path expression ends in a composite value: " + path );
		}
		return columns[0];
	}

	public String[] getWhereColumns() {
		return columns;
	}

	public Type getWhereColumnType() {
		return type;
	}

	public String getName() {
		return currentName == null ? collectionName : currentName;
	}


	public String getCollectionSubquery(Map enabledFilters) throws QueryException {
		return CollectionSubqueryFactory.createCollectionSubquery( joinSequence, enabledFilters, currentColumns() );
	}

	public boolean isCollectionValued() throws QueryException {
		//TODO: is there a better way?
		return collectionName != null && !getPropertyType().isCollectionType();
	}

	public void addAssociation(QueryTranslatorImpl q) throws QueryException {
		q.addJoin( getName(), joinSequence );
	}

	public String addFromAssociation(QueryTranslatorImpl q) throws QueryException {
		if ( isCollectionValued() ) {
			return addFromCollection( q );
		}
		else {
			q.addFrom( currentName, joinSequence );
			return currentName;
		}
	}

	public String addFromCollection(QueryTranslatorImpl q) throws QueryException {
		Type collectionElementType = getPropertyType();

		if ( collectionElementType == null ) {
			throw new QueryException( "must specify 'elements' for collection valued property in from clause: " + path );
		}

		if ( collectionElementType.isEntityType() ) {
			// an association
			QueryableCollection collectionPersister = q.getCollectionPersister( collectionRole );
			Queryable entityPersister = ( Queryable ) collectionPersister.getElementPersister();
			String clazz = entityPersister.getEntityName();

			final String elementName;
			if ( collectionPersister.isOneToMany() ) {
				elementName = collectionName;
				//allow index() function:
				q.decoratePropertyMapping( elementName, collectionPersister );
			}
			else { //many-to-many
				q.addCollection( collectionName, collectionRole );
				elementName = q.createNameFor( clazz );
				addJoin( elementName, ( AssociationType ) collectionElementType );
			}
			q.addFrom( elementName, clazz, joinSequence );
			currentPropertyMapping = new CollectionPropertyMapping( collectionPersister );
			return elementName;
		}
		else {
			// collections of values
			q.addFromCollection( collectionName, collectionRole, joinSequence );
			return collectionName;
		}

	}

	String getCollectionName() {
		return collectionName;
	}

	String getCollectionRole() {
		return collectionRole;
	}

	String getCollectionOwnerName() {
		return collectionOwnerName;
	}

	String getOneToOneOwnerName() {
		return oneToOneOwnerName;
	}

	AssociationType getOwnerAssociationType() {
		return ownerAssociationType;
	}

	String getCurrentProperty() {
		return currentProperty;
	}

	String getCurrentName() {
		return currentName;
	}

	public void fetch(QueryTranslatorImpl q, String entityName) throws QueryException {
		if ( isCollectionValued() ) {
			q.setCollectionToFetch( getCollectionRole(), getCollectionName(), getCollectionOwnerName(), entityName );
		}
		else {
			q.addEntityToFetch( entityName, getOneToOneOwnerName(), getOwnerAssociationType() );
		}
	}
}