/*******************************************************************************
 * Copyright (c) 2005, 2008 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:
 *     IBM Corporation - initial API and implementation
 *     Qnx Software System
 *     Anton Leherbauer (Wind River Systems)
 *     Sergey Prigogin, Google
 *******************************************************************************/
package org.eclipse.cdt.internal.corext.template.c;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import org.eclipse.core.runtime.Assert;
import org.eclipse.jface.text.BadLocationException;
import org.eclipse.jface.text.BadPositionCategoryException;
import org.eclipse.jface.text.Document;
import org.eclipse.jface.text.IDocument;
import org.eclipse.jface.text.IRegion;
import org.eclipse.jface.text.TypedPosition;
import org.eclipse.jface.text.rules.FastPartitioner;
import org.eclipse.jface.text.templates.DocumentTemplateContext;
import org.eclipse.jface.text.templates.GlobalTemplateVariables;
import org.eclipse.jface.text.templates.TemplateBuffer;
import org.eclipse.jface.text.templates.TemplateContext;
import org.eclipse.jface.text.templates.TemplateVariable;
import org.eclipse.text.edits.MalformedTreeException;
import org.eclipse.text.edits.MultiTextEdit;
import org.eclipse.text.edits.RangeMarker;
import org.eclipse.text.edits.ReplaceEdit;
import org.eclipse.text.edits.TextEdit;

import org.eclipse.cdt.core.CCorePlugin;
import org.eclipse.cdt.core.formatter.CodeFormatter;
import org.eclipse.cdt.core.formatter.DefaultCodeFormatterConstants;
import org.eclipse.cdt.core.model.ICProject;
import org.eclipse.cdt.ui.text.ICPartitions;

import org.eclipse.cdt.internal.corext.util.CodeFormatterUtil;

import org.eclipse.cdt.internal.ui.editor.IndentUtil;
import org.eclipse.cdt.internal.ui.text.FastCPartitionScanner;


/**
 * A template editor using the C/C++ formatter to format a template buffer.
 */
public class CFormatter {

	private static final String COMMENT_START= "/*-"; //$NON-NLS-1$
	private static final String COMMENT_END= "*/"; //$NON-NLS-1$

	/** The line delimiter to use if code formatter is not used. */
	private final String fLineDelimiter;
	/** The initial indent level */
	private final int fInitialIndentLevel;
	
	/** Flag indicating whether to use the code formatter or not. */
	private boolean fUseCodeFormatter;
	private final ICProject fProject;

	/**
	 * Creates a CFormatter with the target line delimiter.
	 * 
	 * @param lineDelimiter the line delimiter to use
	 * @param initialIndentLevel the initial indentation level
	 * @param useCodeFormatter <code>true</code> if the core code formatter should be used
	 * @param project the C/C++ project from which to get the preferences, or <code>null</code> for workbench settings
	 */
	public CFormatter(String lineDelimiter, int initialIndentLevel, boolean useCodeFormatter, ICProject project) {
		fLineDelimiter= lineDelimiter;
		fUseCodeFormatter= useCodeFormatter;
		fInitialIndentLevel= initialIndentLevel;
		fProject= project;
	}

	/**
	 * Formats the template buffer.
	 * @param buffer
	 * @param context
	 * @throws BadLocationException
	 */
	public void format(TemplateBuffer buffer, TemplateContext context) throws BadLocationException {
		try {
			VariableTracker tracker= new VariableTracker(buffer);
			IDocument document= tracker.getDocument();
			
			internalFormat(document, context, buffer);
			convertLineDelimiters(document);
			if (isReplacedAreaEmpty(context))
				trimStart(document);
			
			tracker.updateBuffer();
		} catch (MalformedTreeException e) {
			throw new BadLocationException();
		}
	}

	/**
	 * @param document
	 * @param context
	 * @param buffer 
	 * @throws BadLocationException
	 */
	private void internalFormat(IDocument document, TemplateContext context, TemplateBuffer buffer) throws BadLocationException {
		if (fUseCodeFormatter) {
			// try to format and fall back to indenting
			try {
				format(document);
				return;
			} catch (BadLocationException e) {
			} catch (MalformedTreeException e) {
			}
		}
		// fallback: indent
		indent(document, buffer);
	}

	private void convertLineDelimiters(IDocument document) throws BadLocationException {
		int lines= document.getNumberOfLines();
		for (int line= 0; line < lines; line++) {
			IRegion region= document.getLineInformation(line);
			String lineDelimiter= document.getLineDelimiter(line);
			if (lineDelimiter != null)
				document.replace(region.getOffset() + region.getLength(), lineDelimiter.length(), fLineDelimiter);
		}
	}

	private void trimStart(IDocument document) throws BadLocationException {
		trimAtOffset(0, document);
	}

	private String trimAtOffset(int offset, IDocument document) throws BadLocationException {
		int i= offset;
		while ((i < document.getLength()) && Character.isWhitespace(document.getChar(i)))
			i++;
		
		String trim= document.get(offset, i - offset);
		document.replace(offset, i - offset, ""); //$NON-NLS-1$
		return trim;
	}

	private boolean isReplacedAreaEmpty(TemplateContext context) {
		if (context instanceof DocumentTemplateContext) {
			DocumentTemplateContext dtc= (DocumentTemplateContext) context;
			if (dtc.getCompletionLength() == 0) {
				return true;
			}
			try {
				if (dtc.getDocument().get(dtc.getStart(), dtc.getEnd() - dtc.getStart()).trim().length() == 0)
					return true;
			} catch (BadLocationException x) {
				// ignore - this may happen when the document was modified after the initial invocation, and the
				// context does not track the changes properly - don't trim in that case
				return false;
			}
		}
		return false;
	}

	private void format(IDocument doc) throws BadLocationException {
		Map<String, String> options;
		if (fProject != null)
			options= fProject.getOptions(true); 
		else
			options= CCorePlugin.getOptions();
		
		TextEdit edit= CodeFormatterUtil.format(CodeFormatter.K_UNKNOWN, doc.get(), fInitialIndentLevel, fLineDelimiter, options);
		if (edit == null)
			throw new BadLocationException(); // fall back to indenting
		
		edit.apply(doc, TextEdit.UPDATE_REGIONS);
	}

	private void indent(IDocument document, TemplateBuffer buffer) throws BadLocationException, MalformedTreeException {
		prefixSelectionLines(document, buffer);
		adjustIndentation(document);
	}

	/**
	 * Convert leading tabs to correct indentation and add initial indentation level.
	 * 
	 * @param document
	 * @throws BadLocationException 
	 */
	private void adjustIndentation(IDocument document) throws BadLocationException {
		int lines= document.getNumberOfLines();
		if (lines == 0)
			return;

		String option;
		if (fProject == null)
			option= CCorePlugin.getOption(DefaultCodeFormatterConstants.FORMATTER_TAB_CHAR);
		else
			option= fProject.getOption(DefaultCodeFormatterConstants.FORMATTER_TAB_CHAR, true);

		boolean useSpaces= CCorePlugin.SPACE.equals(option);
		int indentWidth= CodeFormatterUtil.getIndentWidth(fProject);
		int tabWidth= CodeFormatterUtil.getTabWidth(fProject);
		
		for (int line= 0; line < lines; ++line) {
			IRegion lineRegion= document.getLineInformation(line);
			String indent= IndentUtil.getCurrentIndent(document, line, false);
			int tabs= 0;
			for (int i = 0; i < indent.length(); i++) {
				if (indent.charAt(i) == '\t') {
					tabs++;
				} else {
					break;
				}
			}
			int totalIndentWidth= (fInitialIndentLevel + tabs) * indentWidth + IndentUtil.computeVisualLength(indent.substring(tabs), tabWidth);
			String newIndent= IndentUtil.changePrefix("", totalIndentWidth, tabWidth, useSpaces); //$NON-NLS-1$
			document.replace(lineRegion.getOffset(), indent.length(), newIndent);
		}
	}

	/**
	 * Prefix each line of <code>line_selection</code> substitutions with
	 * the prefix of the first line.
	 * 
	 * @param document
	 * @param buffer
	 */
	private void prefixSelectionLines(IDocument document, TemplateBuffer buffer) {
		TemplateVariable[] variables= buffer.getVariables();
		for (int i = 0; i < variables.length; i++) {
			if (variables[i].getName().equals(GlobalTemplateVariables.LineSelection.NAME)) {
				if (variables[i].getLength() > 0) {
					final int tabWidth= CodeFormatterUtil.getTabWidth(fProject);
					int delta= 0;
					int[] offsets= variables[i].getOffsets();
					for (int j= 0; j < offsets.length; j++) {
						final int offset = offsets[j] + delta;
						try {
							int startLine= document.getLineOfOffset(offset);
							int startOffset= document.getLineOffset(startLine);
							int endLine= document.getLineOfOffset(offset+variables[i].getLength() - 1);
							String prefix= document.get(startOffset, offset - startOffset);
							String shift= trimAtOffset(offset, document);
							delta -= shift.length();
							if (startLine < endLine) {
								int shiftWidth= IndentUtil.computeVisualLength(shift, tabWidth);
								for (int line= startLine + 1; line <= endLine; ++line) {
									String currentIndent= IndentUtil.getCurrentIndent(document, line, false);
									int indentWidth= IndentUtil.computeVisualLength(currentIndent, tabWidth);
									int newIndentWidth= Math.max(0, indentWidth - shiftWidth);
									// replace current indent with prefix + spaces
									String newIndent= IndentUtil.changePrefix(prefix, prefix.length() + newIndentWidth, 1, true);
									int lineOffset= document.getLineOffset(line);
									document.replace(lineOffset, currentIndent.length(), newIndent);
									delta -= currentIndent.length();
									delta += newIndent.length();
								}
							}
						} catch (BadLocationException exc) {
							break;
						}
					}
				}
				break;
			}
		}
	}

	/**
	 * Wraps a {@link TemplateBuffer} and tracks the variable offsets while changes to the buffer
	 * occur. Whitespace variables are also tracked.
	 */
	private static final class VariableTracker {
		private static final String CATEGORY= "__template_variables"; //$NON-NLS-1$
		private Document fDocument;
		private final TemplateBuffer fBuffer;
		private List<TypedPosition> fPositions;
		
		/**
		 * Creates a new tracker.
		 * 
		 * @param buffer the buffer to track
		 * @throws MalformedTreeException
		 * @throws BadLocationException
		 */
		public VariableTracker(TemplateBuffer buffer) throws MalformedTreeException, BadLocationException {
			Assert.isLegal(buffer != null);
			fBuffer= buffer;
			fDocument= new Document(fBuffer.getString());
			installCStuff(fDocument);
			fDocument.addPositionCategory(CATEGORY);
			fDocument.addPositionUpdater(new ExclusivePositionUpdater(CATEGORY));
			fPositions= createRangeMarkers(fBuffer.getVariables(), fDocument);
		}
		
		/**
		 * Installs a C partitioner with <code>document</code>.
		 *
		 * @param document the document
		 */
		private static void installCStuff(Document document) {
			String[] types= new String[] {
					ICPartitions.C_MULTI_LINE_COMMENT,
					ICPartitions.C_SINGLE_LINE_COMMENT,
					ICPartitions.C_STRING,
					ICPartitions.C_CHARACTER,
					ICPartitions.C_PREPROCESSOR,
					IDocument.DEFAULT_CONTENT_TYPE
			};
			FastPartitioner partitioner= new FastPartitioner(new FastCPartitionScanner(), types);
			partitioner.connect(document);
			document.setDocumentPartitioner(ICPartitions.C_PARTITIONING, partitioner);
		}
		
		/**
		 * Returns the document with the buffer contents. Whitespace variables are decorated with
		 * comments.
		 * 
		 * @return the buffer document
		 */
		public IDocument getDocument() {
			checkState();
			return fDocument;
		}
		
		private void checkState() {
			if (fDocument == null)
				throw new IllegalStateException();
		}

		/**
		 * Restores any decorated regions and updates the buffer's variable offsets.
		 * 
		 * @return the buffer.
		 * @throws MalformedTreeException
		 * @throws BadLocationException
		 */
		public TemplateBuffer updateBuffer() throws MalformedTreeException, BadLocationException {
			checkState();
			TemplateVariable[] variables= fBuffer.getVariables();
			try {
				removeRangeMarkers(fPositions, fDocument, variables);
			} catch (BadPositionCategoryException x) {
				Assert.isTrue(false);
			}
			fBuffer.setContent(fDocument.get(), variables);
			fDocument= null;
			
			return fBuffer;
		}
		
		private List<TypedPosition> createRangeMarkers(TemplateVariable[] variables, IDocument document) throws MalformedTreeException, BadLocationException {
			Map<ReplaceEdit, String> markerToOriginal= new HashMap<ReplaceEdit, String>();
			
			MultiTextEdit root= new MultiTextEdit(0, document.getLength());
			List<TextEdit> edits= new ArrayList<TextEdit>();
			boolean hasModifications= false;
			for (int i= 0; i != variables.length; i++) {
				final TemplateVariable variable= variables[i];
				int[] offsets= variable.getOffsets();
				
				String value= variable.getDefaultValue();
				if (isWhitespaceVariable(value)) {
					// replace whitespace positions with unformattable comments
					String placeholder= COMMENT_START + value + COMMENT_END;
					for (int j= 0; j != offsets.length; j++) {
						ReplaceEdit replace= new ReplaceEdit(offsets[j], value.length(), placeholder);
						root.addChild(replace);
						hasModifications= true;
						markerToOriginal.put(replace, value);
						edits.add(replace);
					}
				} else {
					for (int j= 0; j != offsets.length; j++) {
						RangeMarker marker= new RangeMarker(offsets[j], value.length());
						root.addChild(marker);
						edits.add(marker);
					}
				}
			}
			
			if (hasModifications) {
				// update the document and convert the replaces to markers
				root.apply(document, TextEdit.UPDATE_REGIONS);
			}
			
			List<TypedPosition> positions= new ArrayList<TypedPosition>();
			for (Iterator<TextEdit> it= edits.iterator(); it.hasNext();) {
				TextEdit edit= it.next();
				try {
					// abuse TypedPosition to piggy back the original contents of the position
					final TypedPosition pos= new TypedPosition(edit.getOffset(), edit.getLength(), markerToOriginal.get(edit));
					document.addPosition(CATEGORY, pos);
					positions.add(pos);
				} catch (BadPositionCategoryException x) {
					Assert.isTrue(false);
				}
			}
			
			return positions;
		}
		
		private boolean isWhitespaceVariable(String value) {
			int length= value.length();
			return length == 0 || value.trim().length() == 0;
		}
		
		private void removeRangeMarkers(List<TypedPosition> positions, IDocument document, TemplateVariable[] variables) throws MalformedTreeException, BadLocationException, BadPositionCategoryException {
			
			// revert previous changes
			for (Iterator<TypedPosition> it= positions.iterator(); it.hasNext();) {
				TypedPosition position= it.next();
				// remove and re-add in order to not confuse ExclusivePositionUpdater
				document.removePosition(CATEGORY, position);
				final String original= position.getType();
				if (original != null) {
					document.replace(position.getOffset(), position.getLength(), original);
					position.setLength(original.length());
				}
				document.addPosition(position);
			}
			
			Iterator<TypedPosition> it= positions.iterator();
			for (int i= 0; i != variables.length; i++) {
				TemplateVariable variable= variables[i];

				int[] offsets= new int[variable.getOffsets().length];
				for (int j= 0; j != offsets.length; j++)
					offsets[j]= it.next().getOffset();

				variable.setOffsets(offsets);   
			}

		}
	}
}

