/*******************************************************************************
 *  Copyright (c) 2001, 2011 IBM Corporation and others.
 *  All rights reserved. This program and the accompanying materials
 *  are made available under the terms of the Eclipse Public License v1.0
 *  which accompanies this distribution, and is available at
 *  http://www.eclipse.org/legal/epl-v10.html
 * 
 *  Contributors:
 *     Rational Software - initial implementation
 *     Anton Leherbauer (Wind River Systems)
 *     Sergey Prigogin (Google)
 *******************************************************************************/
package org.eclipse.cdt.ui;

import org.eclipse.core.runtime.CoreException;
import org.eclipse.jface.text.templates.Template;

import org.eclipse.cdt.core.model.ITranslationUnit;

import org.eclipse.cdt.internal.corext.codemanipulation.StubUtility;

/**
 * Class that offers access to the templates contained in the 'Code Templates' preference page.
 * 
 * @noextend This class is not intended to be subclassed by clients.
 * @noinstantiate This class is not intended to be instantiated by clients.
 * @since 2.1
 */
public class CodeGeneration {

	private CodeGeneration() {
	}

	/**
	 * Returns the content for a new header file using the default 'header file' code template.
	 * @param tu The translation unit to create the source for. The translation unit does not need
	 * 		to exist.
	 * @param lineDelimiter The line delimiter to be used.
	 * @return Returns the new content or <code>null</code> if the template is undefined or empty.
	 * @throws CoreException
	 * @since 5.3
	 */
	public static String getHeaderFileContent(Template template, ITranslationUnit tu,
			String lineDelimiter) throws CoreException {	
		return getHeaderFileContent(template, tu, null, null, null, null, null, null, null,
				lineDelimiter);
	}

	/**
	 * Returns the content for a new header file using the default 'header file' code template.
	 * @param tu The translation unit to create the source for. The translation unit does not need
	 * 		to exist.
	 * @param typeComment The comment for the type to created. Used when the code template contains
	 * 		a ${typecomment} variable. Can be <code>null</code> if no comment should be added.
	 * @param typeContent The code of the type, including type declaration and body.
	 * @param lineDelimiter The line delimiter to be used.
	 * @return Returns the new content or <code>null</code> if the template is undefined or empty.
	 * @throws CoreException
	 */
	public static String getHeaderFileContent(ITranslationUnit tu, String typeComment,
			String typeContent, String lineDelimiter) throws CoreException {	
		return getHeaderFileContent(tu, null, null, null, null, typeComment, typeContent, null,
				lineDelimiter);
	}

	/**
	 * Returns the content for a new header file using the default 'header file' code template.
	 * @param template  The file template to use or <code>null</code> for the default template
	 * @param tu The translation unit to create the source for. The translation unit does not need
	 * 		to exist.
	 * @param typeComment The comment for the type to created. Used when the code template contains
	 * 		a ${typecomment} variable. Can be <code>null</code> if no comment should be added.
	 * @param typeContent The code of the type, including type declaration and body.
	 * @param lineDelimiter The line delimiter to be used.
	 * @return Returns the new content or <code>null</code> if the template is undefined or empty.
	 * @throws CoreException
	 */
	public static String getHeaderFileContent(Template template, ITranslationUnit tu,
			String typeComment, String typeContent, String lineDelimiter) throws CoreException {	
		return getHeaderFileContent(template, tu, null, null, null, null, typeComment, typeContent,
				null, lineDelimiter);
	}

	/**
	 * Returns the content for a new header file using the default 'header file' code template.
	 * @param tu The translation unit to create the source for. The translation unit does not need
	 * 		to exist.
	 * @param includes Include statements, or {@code null} if there are no includes.
	 * @param namespaceBegin Beginning of namespace declarations, or {@code null} if there is no
	 * 		namespace.
	 * @param namespaceEnd End of namespace declarations, or {@code null} if there is no
	 * 		namespace.
	 * @param namespaceName Fully qualified namespace name, or {@code null} if there is no
	 * 		namespace.
	 * @param typeComment The comment for the type to created. Used when the code template contains
	 * 		a ${typecomment} variable. Can be <code>null</code> if no comment should be added.
	 * @param typeContent The code of the type, including type declaration and body.
	 * @param typeName The name of the type.
	 * @param lineDelimiter The line delimiter to be used.
	 * @return Returns the new content or <code>null</code> if the template is undefined or empty.
	 * @throws CoreException
	 * @since 5.3
	 */
	public static String getHeaderFileContent(ITranslationUnit tu, String includes,
			String namespaceBegin, String namespaceEnd, String namespaceName, String typeComment,
			String typeContent, String typeName, String lineDelimiter) throws CoreException {	
		return StubUtility.getHeaderFileContent(tu, typeContent,
				getFileComment(tu, lineDelimiter), includes, namespaceBegin, namespaceEnd,
				namespaceName, typeComment, typeName, lineDelimiter);
	}

	/**
	 * Returns the content for a new header file using the default 'header file' code template.
	 * @param template  The file template to use or <code>null</code> for the default template
	 * @param tu The translation unit to create the source for. The translation unit does not need
	 * 		to exist.
	 * @param includes Include statements, or {@code null} if there are no includes.
	 * @param namespaceBegin Beginning of namespace declarations, or {@code null} if there is no
	 * 		namespace.
	 * @param namespaceEnd End of namespace declarations, or {@code null} if there is no
	 * 		namespace.
	 * @param namespaceName Fully qualified namespace name, or {@code null} if there is no
	 * 		namespace.
	 * @param typeComment The comment for the type to created. Used when the code template contains
	 * 		a ${typecomment} variable. Can be <code>null</code> if no comment should be added.
	 * @param typeContent The code of the type, including type declaration and body.
	 * @param typeName The name of the type.
	 * @param lineDelimiter The line delimiter to be used.
	 * @return Returns the new content or <code>null</code> if the template is undefined or empty.
	 * @throws CoreException
	 * @since 5.3
	 */
	public static String getHeaderFileContent(Template template, ITranslationUnit tu,
			String includes, String namespaceBegin, String namespaceEnd, String namespaceName,
			String typeComment, String typeContent, String typeName, String lineDelimiter)
			throws CoreException {	
		return StubUtility.getHeaderFileContent(template, tu, typeContent,
				getFileComment(tu, lineDelimiter), includes, namespaceBegin, namespaceEnd,
				namespaceName, typeComment, typeName, lineDelimiter);
	}

	/**
	 * Returns the content for a new translation unit using the 'source file' code template.
	 * @param tu The translation unit to create the source for. The translation unit does not need
	 * 		to exist.
	 * @param typeComment The comment for the type to created. Used when the code template contains
	 * 		a ${typecomment} variable. Can be <code>null</code> if no comment should be added.
	 * @param typeContent The code of the type, including type declaration and body.
	 * @param lineDelimiter The line delimiter to be used.
	 * @return Returns the new content or <code>null</code> if the template is undefined or empty.
	 * @throws CoreException
	 */
	public static String getBodyFileContent(ITranslationUnit tu, String typeComment,
			String typeContent, String lineDelimiter) throws CoreException {	
		return getBodyFileContent(tu, typeContent, null, null, null, null, typeComment, null,
				lineDelimiter);
	}

	/**
	 * Returns the content for a new translation unit using the 'source file' code template.
	 * @param template  The file template to use or <code>null</code> for the default template
	 * @param tu The translation unit to create the source for. The translation unit does not need
	 * 		to exist.
	 * @param typeComment The comment for the type to created. Used when the code template contains
	 * 		a ${typecomment} variable. Can be <code>null</code> if no comment should be added.
	 * @param typeContent The code of the type, including type declaration and body.
	 * @param lineDelimiter The line delimiter to be used.
	 * @return Returns the new content or <code>null</code> if the template is undefined or empty.
	 * @throws CoreException
	 */
	public static String getBodyFileContent(Template template, ITranslationUnit tu,
			String typeComment, String typeContent, String lineDelimiter) throws CoreException {	
		return getBodyFileContent(template, tu, typeContent, null, null, null, null, typeComment,
				null, lineDelimiter);
	}

	/**
	 * Returns the content for a new source file using the default 'source file' code template.
	 * @param tu The translation unit to create the source for. The translation unit does not need
	 * 		to exist.
	 * @param includes Include statements, or {@code null} if there are no includes.
	 * @param namespaceBegin Beginning of namespace declarations, or {@code null} if there is no
	 * 		namespace.
	 * @param namespaceEnd End of namespace declarations, or {@code null} if there is no
	 * 		namespace.
	 * @param namespaceName Fully qualified namespace name, or {@code null} if there is no
	 * 		namespace.
	 * @param typeComment The comment for the type to created. Used when the code template contains
	 * 		a ${typecomment} variable. Can be <code>null</code> if no comment should be added.
	 * @param typeContent The code of the type, including type declaration and body.
	 * @param typeName The name of the type.
	 * @param lineDelimiter The line delimiter to be used.
	 * @return Returns the new content or <code>null</code> if the template is undefined or empty.
	 * @throws CoreException
	 * @since 5.3
	 */
	public static String getBodyFileContent(ITranslationUnit tu,
			String includes, String namespaceBegin, String namespaceEnd, String namespaceName,
			String typeComment, String typeContent, String typeName, String lineDelimiter)
			throws CoreException {	
		return StubUtility.getBodyFileContent(tu, typeContent, getFileComment(tu, lineDelimiter),
				includes, namespaceBegin, namespaceEnd, namespaceName, typeComment, typeName,
				lineDelimiter);
	}

	/**
	 * Returns the content for a new source file using the default 'source file' code template.
	 * @param template  The file template to use or <code>null</code> for the default template
	 * @param tu The translation unit to create the source for. The translation unit does not need
	 * 		to exist.
	 * @param includes Include statements, or {@code null} if there are no includes.
	 * @param namespaceBegin Beginning of namespace declarations, or {@code null} if there is no
	 * 		namespace.
	 * @param namespaceEnd End of namespace declarations, or {@code null} if there is no
	 * 		namespace.
	 * @param namespaceName Fully qualified namespace name, or {@code null} if there is no
	 * 		namespace.
	 * @param typeComment The comment for the type to created. Used when the code template contains
	 * 		a ${typecomment} variable. Can be <code>null</code> if no comment should be added.
	 * @param typeContent The code of the type, including type declaration and body.
	 * @param typeName The name of the type.
	 * @param lineDelimiter The line delimiter to be used.
	 * @return Returns the new content or <code>null</code> if the template is undefined or empty.
	 * @throws CoreException
	 * @since 5.3
	 */
	public static String getBodyFileContent(Template template, ITranslationUnit tu,
			String includes, String namespaceBegin, String namespaceEnd, String namespaceName,
			String typeComment, String typeContent, String typeName, String lineDelimiter)
			throws CoreException {	
		return StubUtility.getBodyFileContent(template, tu, typeContent,
				getFileComment(tu, lineDelimiter), includes, namespaceBegin, namespaceEnd,
				namespaceName, typeComment, typeName, lineDelimiter);
	}

	/**
	 * Returns the content for a new translation unit using the 'test file' code template.
	 * @param tu The translation unit to create the source for. The translation unit does not need
	 * 		to exist.
	 * @param includes Include statements, or {@code null} if there are no includes.
	 * @param namespaceBegin Beginning of namespace declarations, or {@code null} if there is no
	 * 		namespace.
	 * @param namespaceEnd End of namespace declarations, or {@code null} if there is no
	 * 		namespace.
	 * @param namespaceName Fully qualified namespace name, or {@code null} if there is no
	 * 		namespace.
	 * @param testCases The test cases code.
	 * @param typeName The name of the type.
	 * @param lineDelimiter The line delimiter to be used.
	 * @return Returns the new content or <code>null</code> if the template is undefined or empty.
	 * @throws CoreException
	 * @since 5.3
	 */
	public static String getTestFileContent(ITranslationUnit tu,
			String includes, String namespaceBegin, String namespaceEnd, String namespaceName,
			String testCases, String typeName, String lineDelimiter) throws CoreException {	
		return StubUtility.getTestFileContent(tu, testCases, getFileComment(tu, lineDelimiter),
				includes, namespaceBegin, namespaceEnd, namespaceName, typeName, lineDelimiter);
	}

	/**
	 * Returns the content of the body for a method using the method body template.
	 * <code>null</code> is returned if the template is empty.
	 * <p>The returned string is unformatted and not indented.
	 * 
	 * @param tu The translation unit to which the method belongs. The translation unit does not need to exist.
	 * @param typeName Name of the type to which the method belongs.
	 * @param methodName Name of the method.
	 * @param bodyStatement The code to be entered at the place of the variable ${body_statement}. 
	 * @param lineDelimiter The line delimiter to be used.
	 * @return Returns the constructed body content or <code>null</code> if
	 * the comment code template is empty. The returned string is unformatted and and has no indent (formatting required).
	 * @throws CoreException Thrown when the evaluation of the code template fails.
	 */	
	public static String getMethodBodyContent(ITranslationUnit tu, String typeName,
			String methodName, String bodyStatement, String lineDelimiter) throws CoreException {
		return StubUtility.getMethodBodyContent(tu.getCProject(), typeName, methodName,
				bodyStatement, lineDelimiter);
	}

	/**
	 * Returns the content of the body for a constructor using the constructor body template.
	 * <code>null</code> is returned if the template is empty.
	 * <p>The returned string is unformatted and not indented.
	 * 
	 * @param tu The translation unit to which the method belongs. The translation unit
	 * 		does not need to exist.
	 * @param typeName Name of the type to which the constructor belongs.
	 * @param bodyStatement The code to be entered at the place of the variable ${body_statement}. 
	 * @param lineDelimiter The line delimiter to be used.
	 * @return Returns the constructed body content or <code>null</code> if the comment code
	 * 		template is empty. The returned string is unformatted and and has no indent
	 * 		(formatting required).
	 * @throws CoreException Thrown when the evaluation of the code template fails.
	 */	
	public static String getConstructorBodyContent(ITranslationUnit tu, String typeName,
			String bodyStatement, String lineDelimiter) throws CoreException {
		return StubUtility.getConstructorBodyContent(tu.getCProject(), typeName, bodyStatement,
				lineDelimiter);
	}

	/**
	 * Returns the content of the body for a destructor using the destructor body template.
	 * <code>null</code> is returned if the template is empty.
	 * <p>The returned string is unformatted and not indented.
	 * 
	 * @param tu The translation unit to which the method belongs. The translation unit
	 * 		does not need to exist.
	 * @param typeName Name of the type to which the constructor belongs.
	 * @param bodyStatement The code to be entered at the place of the variable ${body_statement}. 
	 * @param lineDelimiter The line delimiter to be used.
	 * @return Returns the constructed body content or <code>null</code> if the comment code
	 * 		template is empty. The returned string is unformatted and and has no indent
	 * 		(formatting required).
	 * @throws CoreException Thrown when the evaluation of the code template fails.
	 */	
	public static String getDestructorBodyContent(ITranslationUnit tu, String typeName,
			String bodyStatement, String lineDelimiter) throws CoreException {
		return StubUtility.getDestructorBodyContent(tu.getCProject(), typeName, bodyStatement,
				lineDelimiter);
	}

	/**
	 * Returns the content of the class definition body using the class body template.
	 * <code>null</code> is returned if the template is empty.
	 * <p>The returned string is unformatted and not indented.
	 * 
	 * @param tu The translation unit to which the method belongs. The translation unit
	 * 		does not need to exist.
	 * @param className The name of the class.
	 * @param classMemberDeclarations The code to be entered at the place of the variable
	 * 		${declarations}. 
	 * @param lineDelimiter The line delimiter to be used.
	 * @return Returns the constructed class body content or <code>null</code> if
	 * 		the class body code template is empty. The returned string is unformatted and
	 * 		has no indent (formatting required).
	 * @throws CoreException Thrown when the evaluation of the code template fails.
	 * @since 5.3
	 */	
	public static String getClassBodyContent(ITranslationUnit tu, String className,
			String classMemberDeclarations, String lineDelimiter)
			throws CoreException {
		return StubUtility.getClassBodyContent(tu.getCProject(), className, classMemberDeclarations,
				lineDelimiter);
	}

	/**
	 * Returns the content of the beginning of a namespace declaration using the corresponding
	 * template. <code>null</code> is returned if the template is empty.
	 * <p>The returned string is unformatted and not indented.
	 * 
	 * @param tu The translation unit to which the method belongs. The translation unit
	 * 		does not need to exist.
	 * @param namespaceName The name of the namespace.
	 * @param lineDelimiter The line delimiter to be used.
	 * @return Returns the constructed beginning of a namespace declaration,or <code>null</code> if
	 * 		the namespace code template is empty. The returned string is unformatted and has no
	 * 		indent (formatting required).
	 * @throws CoreException Thrown when the evaluation of the code template fails.
	 * @since 5.3
	 */	
	public static String getNamespaceBeginContent(ITranslationUnit tu, String namespaceName,
			String lineDelimiter) throws CoreException {
		return StubUtility.getNamespaceBeginContent(tu.getCProject(), namespaceName, lineDelimiter);
	}

	/**
	 * Returns the content of the end of a namespace declaration using the corresponding
	 * template. <code>null</code> is returned if the template is empty.
	 * <p>The returned string is unformatted and not indented.
	 * 
	 * @param tu The translation unit to which the method belongs. The translation unit
	 * 		does not need to exist.
	 * @param namespaceName The name of the namespace.
	 * @param lineDelimiter The line delimiter to be used.
	 * @return Returns the constructed end of a namespace declaration,or <code>null</code> if
	 * 		the namespace code template is empty. The returned string is unformatted and has no
	 * 		indent (formatting required).
	 * @throws CoreException Thrown when the evaluation of the code template fails.
	 * @since 5.3
	 */	
	public static String getNamespaceEndContent(ITranslationUnit tu, String namespaceName,
			String lineDelimiter) throws CoreException {
		return StubUtility.getNamespaceEndContent(tu.getCProject(), namespaceName, lineDelimiter);
	}

	/**
	 * Returns the content for a new file comment using the 'file comment' code template.
	 * The returned content is unformatted and is not indented.
	 * @param tu The translation unit to add the comment to. The translation unit does not need
	 * 		to exist.
	 * @param lineDelimiter The line delimiter to be used.
	 * @return Returns the new content or <code>null</code> if the code template is undefined
	 * 		or empty. The returned content is unformatted and is not indented.
	 * @throws CoreException Thrown when the evaluation of the code template fails.
	 * @since 5.0
	 */	
	public static String getFileComment(ITranslationUnit tu, String lineDelimiter)
			throws CoreException {
		return StubUtility.getFileComment(tu, lineDelimiter);
	}
	
	/**
	 * Returns the content for a new type comment using the 'typecomment' code template.
	 * The returned content is unformatted and is not indented.
	 * @param tu The translation unit where the type is contained. The translation unit
	 * 		does not need to exist.
	 * @param typeQualifiedName The name of the type to which the comment is added. For inner types
	 * 		the name must be qualified and include the outer types names (dot separated). 
	 * @param lineDelimiter The line delimiter to be used.
	 * @return Returns the new content or <code>null</code> if the code template is undefined
	 * 		or empty. The returned content is unformatted and is not indented.
	 * @throws CoreException
	 */	
	public static String getClassComment(ITranslationUnit tu, String typeQualifiedName,
			String lineDelimiter) throws CoreException {
		return StubUtility.getClassComment(tu, typeQualifiedName, lineDelimiter);
	}

	/**
	 * Returns the comment for a method using the method comment code template.
	 * <code>null</code> is returned if the template is empty.
	 * <p>The returned string is unformatted and not indented.
	 * 
	 * @param tu The translation unit to which the method belongs. The translation unit
	 * 		does not need to exist.
	 * @param declaringTypeName Name of the type to which the method belongs.
	 * @param methodName Name of the method.
	 * @param paramNames Names of the parameters for the method.
	 * @param excTypeSig Thrown exceptions.
	 * @param retTypeSig Return type.
	 * @param lineDelimiter The line delimiter to be used.
	 * @return Returns the constructed comment or <code>null</code> if the comment code template
	 * 		is empty. The returned content is unformatted and not indented (formatting required).
	 * @throws CoreException Thrown when the evaluation of the code template fails.
	 */
	public static String getMethodComment(ITranslationUnit tu, String declaringTypeName,
			String methodName, String[] paramNames, String[] excTypeSig, String retTypeSig,
			String lineDelimiter) throws CoreException {
		return StubUtility.getMethodComment(tu, declaringTypeName, methodName, paramNames,
				excTypeSig, retTypeSig, lineDelimiter);
	}

	/**
	 * Returns the comment for a constructor using the constructor comment code template.
	 * <code>null</code> is returned if the template is empty.
	 * <p>The returned string is unformatted and not indented.
	 * 
	 * @param tu The translation unit to which the method belongs. The translation unit
	 * 		does not need to exist.
	 * @param declaringTypeName Name of the type to which the method belongs.
	 * @param paramNames Names of the parameters for the method.
	 * @param excTypeSig Thrown exceptions.
	 * @param lineDelimiter The line delimiter to be used.
	 * @return Returns the constructed comment or <code>null</code> if the comment code template
	 * 		is empty. The returned content is unformatted and not indented (formatting required).
	 * @throws CoreException Thrown when the evaluation of the code template fails.
	 */
	public static String getConstructorComment(ITranslationUnit tu, String declaringTypeName,
			String[] paramNames, String[] excTypeSig, String lineDelimiter) throws CoreException {
		return StubUtility.getConstructorComment(tu, declaringTypeName, paramNames, excTypeSig,
				lineDelimiter);
	}

	/**
	 * Returns the comment for a destructor using the destructor comment code template.
	 * <code>null</code> is returned if the template is empty.
	 * <p>The returned string is unformatted and not indented.
	 * 
	 * @param tu The translation unit to which the method belongs. The translation unit
	 * 		does not need to exist.
	 * @param declaringTypeName Name of the type to which the method belongs.
	 * @param excTypeSig Thrown exceptions.
	 * @param lineDelimiter The line delimiter to be used.
	 * @return Returns the constructed comment or <code>null</code> if the comment code template
	 * 		is empty. The returned content is unformatted and not indented (formatting required).
	 * @throws CoreException Thrown when the evaluation of the code template fails.
	 */
	public static String getDestructorComment(ITranslationUnit tu, String declaringTypeName,
			String[] excTypeSig, String lineDelimiter) throws CoreException {
		return StubUtility.getDestructorComment(tu, declaringTypeName, excTypeSig, lineDelimiter);
	}
}
