/*******************************************************************************
 * Copyright (c) 2003 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials 
 * are made available under the terms of the Common Public License v0.5 
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/cpl-v05.html
 * 
 * Contributors:
 *     IBM Corp. - Rational Software - initial implementation
 ******************************************************************************/
/*
 * Created on Jul 29, 2003
 */
package org.eclipse.cdt.core.search;

import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;

import org.eclipse.cdt.core.model.ICElement;
import org.eclipse.cdt.core.parser.ISourceElementCallbackDelegate;
import org.eclipse.cdt.core.parser.ast.ASTAccessVisibility;
import org.eclipse.cdt.core.parser.ast.ASTClassKind;
import org.eclipse.cdt.core.parser.ast.ASTPointerOperator;
import org.eclipse.cdt.core.parser.ast.IASTClassSpecifier;
import org.eclipse.cdt.core.parser.ast.IASTElaboratedTypeSpecifier;
import org.eclipse.cdt.core.parser.ast.IASTEnumerationSpecifier;
import org.eclipse.cdt.core.parser.ast.IASTEnumerator;
import org.eclipse.cdt.core.parser.ast.IASTField;
import org.eclipse.cdt.core.parser.ast.IASTFunction;
import org.eclipse.cdt.core.parser.ast.IASTMacro;
import org.eclipse.cdt.core.parser.ast.IASTMethod;
import org.eclipse.cdt.core.parser.ast.IASTNamespaceDefinition;
import org.eclipse.cdt.core.parser.ast.IASTOffsetableElement;
import org.eclipse.cdt.core.parser.ast.IASTOffsetableNamedElement;
import org.eclipse.cdt.core.parser.ast.IASTParameterDeclaration;
import org.eclipse.cdt.core.parser.ast.IASTQualifiedNameElement;
import org.eclipse.cdt.core.parser.ast.IASTReference;
import org.eclipse.cdt.core.parser.ast.IASTSimpleTypeSpecifier;
import org.eclipse.cdt.core.parser.ast.IASTTypeSpecifier;
import org.eclipse.cdt.core.parser.ast.IASTTypedefDeclaration;
import org.eclipse.cdt.core.parser.ast.IASTVariable;
import org.eclipse.cdt.internal.core.parser.util.ASTUtil;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IProgressMonitor;

/**
 * @author aniefer
 *
 * To change the template for this generated type comment go to
 * Window>Preferences>Java>Code Generation>Code and Comments
 */
public class BasicSearchResultCollector implements ICSearchResultCollector {

	public void aboutToStart() {
		results = new HashSet();
	}

	public void done() {
	}
	
	public IProgressMonitor getProgressMonitor() {
		return null;
	}

	public IMatch createMatch(Object fileResource, int start, int end, ISourceElementCallbackDelegate node ) throws CoreException 
	{
		BasicSearchMatch result = new BasicSearchMatch();
		return createMatch( result, fileResource, start, end, node );
	}
	
	public IMatch createMatch( BasicSearchMatch result, Object fileResource, int start, int end, ISourceElementCallbackDelegate node ) throws CoreException {
		if( fileResource instanceof IResource )
			result.resource = (IResource) fileResource;
		else if( fileResource instanceof IPath )
			result.path = (IPath) fileResource;
			
		result.startOffset = start;
		result.endOffset = end;
		result.parentName = "";
		
		IASTOffsetableNamedElement offsetable = null;

		if( node instanceof IASTReference ){
			offsetable = (IASTOffsetableNamedElement) ((IASTReference)node).getReferencedElement();
			result.name = ((IASTReference)node).getName();
		} else if( node instanceof IASTOffsetableNamedElement ){
			offsetable = (IASTOffsetableNamedElement)node;
			result.name = offsetable.getName();
		}
		
		result.parentName = "";
		String [] names = null;
		if( offsetable instanceof IASTEnumerator ){
			IASTEnumerator enumerator = (IASTEnumerator) offsetable;
			names = enumerator.getOwnerEnumerationSpecifier().getFullyQualifiedName();
		} else if( offsetable instanceof IASTQualifiedNameElement ) {
			names = ((IASTQualifiedNameElement) offsetable).getFullyQualifiedName();
		}

		if( names != null ){
			for( int i = 0; i < names.length - 1; i++ ){
				if( i > 0 )
					result.parentName += "::";
			
				result.parentName += names[ i ];
			}
		}
		if (offsetable instanceof IASTVariable){
			result.returnType = ASTUtil.getType(((IASTVariable)offsetable).getAbstractDeclaration());
		}
		if( offsetable instanceof IASTFunction ){
			result.name += getParameterString( (IASTFunction) offsetable );
			result.returnType = ASTUtil.getType(((IASTFunction)offsetable).getReturnType());
		}
		
		setElementInfo( result, offsetable );
		
		return result;
	}


	/**
	 * @param function
	 * @return
	 */
	private String getParameterString(IASTFunction function) {
		if( function == null )
			return "";
		
		String paramString = "(";
			
		Iterator iter = function.getParameters();
		
		boolean first = true;
		while( iter.hasNext() ){
			IASTParameterDeclaration param = (IASTParameterDeclaration) iter.next();
			
			if( !first ) paramString += ", ";
			
			IASTTypeSpecifier typeSpec = param.getTypeSpecifier();
			if( param.isConst() )
				paramString += "const ";

			if( typeSpec instanceof IASTSimpleTypeSpecifier ){
				paramString += ((IASTSimpleTypeSpecifier)typeSpec).getTypename();
			} else if( typeSpec instanceof IASTOffsetableNamedElement ){
				paramString += ((IASTOffsetableNamedElement)typeSpec).getName();
			} else if( typeSpec instanceof IASTElaboratedTypeSpecifier ){
				ASTClassKind kind = ((IASTElaboratedTypeSpecifier)typeSpec).getClassKind();
				if( kind == ASTClassKind.CLASS ){
					paramString += "class ";
				} else if( kind == ASTClassKind.STRUCT ){
					paramString += "struct ";
				} else if( kind == ASTClassKind.ENUM ){
					paramString += "enum ";
				} else if( kind == ASTClassKind.UNION ){
					paramString += "union ";
				}
				paramString += ((IASTElaboratedTypeSpecifier)typeSpec).getName();
			}
				
			Iterator ptrs = param.getPointerOperators();
			if( ptrs.hasNext() ) paramString += " ";
			
			while( ptrs.hasNext() ){
				ASTPointerOperator ptr = (ASTPointerOperator)ptrs.next();
				if( ptr == ASTPointerOperator.POINTER )
					paramString += "*";
				else if( ptr == ASTPointerOperator.REFERENCE )
					paramString += "&";
				else if( ptr == ASTPointerOperator.CONST_POINTER )
					paramString += " const * ";
				else if( ptr == ASTPointerOperator.VOLATILE_POINTER )
					paramString += " volatile * ";
					
				ptr = ASTPointerOperator.POINTER;
			}
			
			first = false;
		}
		
		paramString += ")";
		return paramString;
	}

	public boolean acceptMatch(IMatch match) throws CoreException {
		if( !results.contains( match ) ){
			results.add( match );
			return true;
		}
		return false;
	}
	
	public Set getSearchResults(){
		return results;
	}
	
	private void setElementInfo( BasicSearchMatch match, IASTOffsetableElement node ){
		//ImageDescriptor imageDescriptor = null;
		if( node instanceof IASTClassSpecifier ||
			node instanceof IASTElaboratedTypeSpecifier ){
			
			ASTClassKind kind = null;
			if (node instanceof IASTClassSpecifier){
				kind = ((IASTClassSpecifier)node).getClassKind();
			}
			else{
				kind = ((IASTElaboratedTypeSpecifier)node).getClassKind();
			}
			
			if( kind == ASTClassKind.CLASS ){
				match.type = ICElement.C_CLASS;
			} else if ( kind == ASTClassKind.STRUCT ){
				match.type = ICElement.C_STRUCT;
			} else if ( kind == ASTClassKind.UNION ){
				match.type = ICElement.C_UNION;
			}
		} else if ( node instanceof IASTNamespaceDefinition ){
			match.type = ICElement.C_NAMESPACE;
		} else if ( node instanceof IASTEnumerationSpecifier ){
			match.type = ICElement.C_ENUMERATION;
		} else if ( node instanceof IASTMacro ){
			match.type = ICElement.C_MACRO;
		} else if ( node instanceof IASTField ){
			match.type = ICElement.C_FIELD;
			IASTField  field = (IASTField)node;
			ASTAccessVisibility visibility = field.getVisiblity();
			if( visibility == ASTAccessVisibility.PUBLIC ){
				match.visibility = ICElement.CPP_PUBLIC;
			} else if ( visibility == ASTAccessVisibility.PRIVATE ) {
				match.visibility = ICElement.CPP_PRIVATE;
			} // else protected, there is no ICElement.CPP_PROTECTED
			match.isConst = field.getAbstractDeclaration().isConst();
			match.isStatic = field.isStatic();
		} else if ( node instanceof IASTVariable ){
			match.type = ICElement.C_VARIABLE;
			IASTVariable variable = (IASTVariable)node;
			match.isConst  = variable.getAbstractDeclaration().isConst();
		} else if ( node instanceof IASTEnumerator ){
			match.type = ICElement.C_ENUMERATOR;
		} else if ( node instanceof IASTMethod ){
			match.type = ICElement.C_METHOD;
			IASTMethod method = (IASTMethod) node;
			ASTAccessVisibility visibility = method.getVisiblity();
			if( visibility == ASTAccessVisibility.PUBLIC ){
				match.visibility = ICElement.CPP_PUBLIC;
			} else if ( visibility == ASTAccessVisibility.PRIVATE ) {
				match.visibility = ICElement.CPP_PRIVATE;
			} // else protected, there is no ICElement.CPP_PROTECTED
			match.isConst = method.isConst();
			match.isVolatile = method.isVolatile();
			match.isStatic = method.isStatic();
		} else if ( node instanceof IASTFunction ){
			match.type = ICElement.C_FUNCTION;
			IASTFunction function = (IASTFunction)node;
			match.isStatic = function.isStatic();
		} else if ( node instanceof IASTTypedefDeclaration ){
			match.type = ICElement.C_TYPEDEF;
		}
	}
	
	private Set results;
}