/*******************************************************************************
 * Copyright (c) 2007, 2013 David Green 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:
 *     David Green - initial API and implementation
 *******************************************************************************/
package org.eclipse.mylyn.internal.wikitext.ui.editor.syntax;

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

import org.eclipse.jface.text.IDocument;
import org.eclipse.jface.text.IDocumentPartitioner;
import org.eclipse.jface.text.ITypedRegion;
import org.eclipse.jface.text.TextAttribute;
import org.eclipse.jface.text.rules.IToken;
import org.eclipse.jface.text.rules.ITokenScanner;
import org.eclipse.mylyn.internal.wikitext.ui.WikiTextUiPlugin;
import org.eclipse.mylyn.internal.wikitext.ui.editor.preferences.Preferences;
import org.eclipse.mylyn.internal.wikitext.ui.editor.syntax.FastMarkupPartitioner.MarkupPartition;
import org.eclipse.mylyn.internal.wikitext.ui.viewer.CssStyleManager;
import org.eclipse.mylyn.internal.wikitext.ui.viewer.FontState;
import org.eclipse.mylyn.wikitext.parser.css.CssParser;
import org.eclipse.mylyn.wikitext.parser.css.CssRule;
import org.eclipse.osgi.util.NLS;
import org.eclipse.swt.custom.StyleRange;
import org.eclipse.swt.graphics.Font;

/**
 * A token scanner that uses the results of the {@link FastMarkupPartitioner} to identify tokens.
 *
 * @author David Green
 */
public class MarkupTokenScanner implements ITokenScanner {

	private Token currentToken = null;

	private Iterator<Token> tokenIt = null;

	private CssStyleManager styleManager;

	private FontState defaultState;

	private Preferences preferences;

	private final CssParser cssParser = new CssParser();

	public MarkupTokenScanner(Font defaultFont, Font defaultMonospaceFont) {
		initialize(defaultFont, defaultMonospaceFont);
		reloadPreferences();
	}

	/**
	 * Reset the fonts used by this token scanner.
	 *
	 * @param defaultFont
	 *            the default font, must not be null.
	 * @param defaultMonospaceFont
	 *            the default monospace font, or null if a suitable default should be selected
	 */
	public void resetFonts(Font defaultFont, Font defaultMonospaceFont) {
		if (defaultFont == null) {
			throw new IllegalArgumentException();
		}
		initialize(defaultFont, defaultMonospaceFont);
	}

	private void initialize(Font defaultFont, Font defaultMonospaceFont) {
		styleManager = new CssStyleManager(defaultFont, defaultMonospaceFont);
		defaultState = styleManager.createDefaultFontState();
	}

	public void reloadPreferences() {
		preferences = WikiTextUiPlugin.getDefault().getPreferences();
	}

	public int getTokenLength() {
		return currentToken == null ? -1 : currentToken.getLength();
	}

	public int getTokenOffset() {
		return currentToken == null ? -1 : currentToken.getOffset();
	}

	public IToken nextToken() {
		if (tokenIt != null && tokenIt.hasNext()) {
			currentToken = tokenIt.next();
		} else {
			currentToken = null;
			tokenIt = null;
			return org.eclipse.jface.text.rules.Token.EOF;
		}
		return currentToken;
	}

	public void setRange(IDocument document, int offset, int length) {
		IDocumentPartitioner partitioner = document.getDocumentPartitioner();
		List<Token> tokens = null;

		if (partitioner instanceof FastMarkupPartitioner) {
			FastMarkupPartitioner fastMarkupPartitioner = (FastMarkupPartitioner) partitioner;
			ITypedRegion[] partitioning = partitioner.computePartitioning(offset, length);
			if (partitioning != null) {
				tokens = new ArrayList<>();

				ITypedRegion[] partitions = ((FastMarkupPartitioner) partitioner).getScanner()
						.computePartitions(document, offset, length);
				int lastEnd = offset;

				Token defaultToken;
				{
					StyleRange styleRange = styleManager.createStyleRange(defaultState, 0, 1);
					TextAttribute textAttribute = createTextAttribute(styleRange);
					defaultToken = new Token(defaultState, textAttribute, offset, length);
				}
				if (partitions != null) {
					for (ITypedRegion region : partitions) {
						if (region.getOffset() >= (offset + length)) {
							break;
						}
						if ((region.getOffset() + region.getLength()) < offset) {
							continue;
						}
						if (region instanceof MarkupPartition) {
							MarkupPartition partition = (MarkupPartition) region;

							if (lastEnd < partition.getOffset()) {
								Token blockBridgeToken = new Token(defaultToken.fontState, defaultToken.getData(),
										lastEnd, partition.getOffset() - lastEnd);
								addToken(tokens, blockBridgeToken);
							}

							// a token that spans the whole block
							Token blockToken = createToken(partition);
							if (blockToken == null) {
								blockToken = defaultToken;
							}
							if (!partition.getBlock().isSpansComputed()) {
								fastMarkupPartitioner.reparse(document, partition.getBlock());
							}
							List<Span> spans = partition.getSpans();
							if (spans != null) {
								for (Span span : spans) {
									if (span.getOffset() < lastEnd) {
										continue;
									}
									Token spanToken = createToken(blockToken.getFontState(), span);
									if (spanToken != null) {
										int blockTokenStartOffset = lastEnd < offset ? offset : lastEnd;
										if (blockTokenStartOffset < spanToken.getOffset()) {
											int blockTokenLength = spanToken.getOffset() - blockTokenStartOffset;
											final Token blockBridgeToken = new Token(blockToken.fontState,
													blockToken.getData(), blockTokenStartOffset, blockTokenLength);
											addToken(tokens, blockBridgeToken);
										}

										Token[] spanTokens = null;
										if (!span.getChildren().isEmpty()) {
											spanTokens = splitSpan(spanToken, span, defaultToken);
										}
										if (spanTokens != null) {
											for (Token spanSplitToken : spanTokens) {
												addToken(tokens, spanSplitToken);
											}
										} else {
											addToken(tokens, spanToken);
										}
										lastEnd = spanToken.offset + spanToken.length;
										if (lastEnd > partition.getOffset() + partition.getLength()) {
											throw new IllegalStateException();
										}
									}
								}
							}
							final int partitionEnd = partition.getOffset() + partition.getLength();
							if (lastEnd < partitionEnd) {
								final int realLastEnd = Math.max(lastEnd, partition.getOffset());
								int diff = (partitionEnd) - realLastEnd;
								if (diff > 0) {
									int blockTokenStartOffset = realLastEnd;
									int blockTokenLength = diff;
									final Token blockBridgeToken = new Token(blockToken.fontState, blockToken.getData(),
											blockTokenStartOffset, blockTokenLength);
									addToken(tokens, blockBridgeToken);
									lastEnd = blockTokenStartOffset + blockTokenLength;
									if (lastEnd > partition.getOffset() + partition.getLength()) {
										throw new IllegalStateException();
									}
								}
							}
						}
					}
				}
				if (lastEnd < (offset + length)) {
					addToken(tokens, new Token(defaultToken.fontState, defaultToken.getData(), lastEnd,
							length - (lastEnd - offset)));
				}
			}
		}

		currentToken = null;
		if (tokens == null || tokens.isEmpty()) {
			tokenIt = null;
		} else {
			Iterator<Token> it = tokens.iterator();
			while (it.hasNext()) {
				Token next = it.next();
				if (next.getOffset() < offset) {
					it.remove();
				} else if (next.getOffset() + next.getLength() > (offset + length)) {
					it.remove();
				}
			}
			tokenIt = tokens.iterator();
		}

	}

	protected TextAttribute createTextAttribute(StyleRange styleRange) {
		int fontStyle = styleRange.fontStyle;
		if (styleRange.strikeout) {
			fontStyle |= TextAttribute.STRIKETHROUGH;
		}
		if (styleRange.underline) {
			fontStyle |= TextAttribute.UNDERLINE;
		}
		return new TextAttribute(styleRange.foreground, styleRange.background, fontStyle, styleRange.font);
	}

	/**
	 * handle nested spans: given a token for a specific span, split it into one or more tokens based on analyzing its
	 * children
	 *
	 * @return an array of tokens that contiguously cover the region represented by the original span.
	 */
	private Token[] splitSpan(Token spanToken, Span span, Token defaultToken) {
		List<Token> tokens = new ArrayList<>(span.getChildren().size() + 1);
		int previousEnd = spanToken.offset;
		for (Span child : span.getChildren().asList()) {
			if (child.getOffset() > previousEnd) {
				tokens.add(new Token(spanToken.fontState, spanToken.getData(), previousEnd,
						child.getOffset() - previousEnd));
			}
			Token childToken = createToken(spanToken.fontState, child);
			if (childToken == null) {
				StyleRange styleRange = styleManager.createStyleRange(spanToken.fontState, 0, 1);
				TextAttribute textAttribute = createTextAttribute(styleRange);
				childToken = new Token(spanToken.fontState, textAttribute, child.getOffset(), child.getLength());
			}
			if (child.getChildren().isEmpty()) {
				tokens.add(childToken);
			} else {
				// recursively apply to children
				for (Token t : splitSpan(childToken, child, defaultToken)) {
					tokens.add(t);
				}
			}
			previousEnd = child.getEndOffset();
		}
		if (previousEnd < span.getEndOffset()) {
			tokens.add(new Token(spanToken.fontState, spanToken.getData(), previousEnd,
					span.getEndOffset() - previousEnd));
		}
		return tokens.toArray(new Token[tokens.size()]);
	}

	private void addToken(List<Token> tokens, Token newToken) {
		checkAddToken(tokens, newToken);
		tokens.add(newToken);
	}

	private void checkAddToken(List<Token> tokens, Token newToken) {
		if (newToken.getLength() <= 0) {
			throw new IllegalStateException(
					NLS.bind(Messages.MarkupTokenScanner_badTokenLength, new Object[] { newToken.getLength() }));
		}
		if (newToken.getOffset() < 0) {
			throw new IllegalStateException(
					NLS.bind(Messages.MarkupTokenScanner_badTokenOffset, new Object[] { newToken.getOffset() }));
		}
		if (!tokens.isEmpty()) {
			Token previous = tokens.get(tokens.size() - 1);
			if (previous.getOffset() >= newToken.getOffset()) {
				throw new IllegalStateException(Messages.MarkupTokenScanner_2);
			} else if (previous.getOffset() + previous.getLength() > newToken.getOffset()) {
				throw new IllegalStateException(Messages.MarkupTokenScanner_3);
			}
		}
	}

	private Token createToken(FontState parentState, Span span) {
		if (span.getLength() == 0) {
			return null;
		}
		String cssStyles = null;
		String key = null;
		switch (span.getType()) {
		case BOLD:
			key = Preferences.PHRASE_BOLD;
			break;
		case CITATION:
			key = Preferences.PHRASE_CITATION;
			break;
		case CODE:
			key = Preferences.PHRASE_CODE;
			break;
		case DELETED:
			key = Preferences.PHRASE_DELETED_TEXT;
			break;
		case EMPHASIS:
			key = Preferences.PHRASE_EMPHASIS;
			break;
		case INSERTED:
			key = Preferences.PHRASE_INSERTED_TEXT;
			break;
		case ITALIC:
			key = Preferences.PHRASE_ITALIC;
			break;
		case MONOSPACE:
			key = Preferences.PHRASE_MONOSPACE;
			break;
		case QUOTE:
			key = Preferences.PHRASE_QUOTE;
			break;
		case SPAN:
			key = Preferences.PHRASE_SPAN;
			break;
		case STRONG:
			key = Preferences.PHRASE_STRONG;
			break;
		case SUBSCRIPT:
			key = Preferences.PHRASE_SUBSCRIPT;
			break;
		case SUPERSCRIPT:
			key = Preferences.PHRASE_SUPERSCRIPT;
			break;
		case UNDERLINED:
			key = Preferences.PHRASE_UNDERLINED;
			break;
		}
		cssStyles = preferences.getCssByPhraseModifierType().get(key);
		if (cssStyles == null && span.getAttributes().getCssStyle() == null && span.getChildren().isEmpty()) {
			return null;
		}
		FontState fontState = new FontState(parentState);
		if (cssStyles != null) {
			processCssStyles(fontState, parentState, cssStyles);
		}
		if (span.getAttributes().getCssStyle() != null) {
			processCssStyles(fontState, parentState, span.getAttributes().getCssStyle());
		}
		StyleRange styleRange = styleManager.createStyleRange(fontState, 0, 1);

		TextAttribute textAttribute = createTextAttribute(styleRange);
		return new Token(fontState, textAttribute, span.getOffset(), span.getLength());
	}

	private Token createToken(MarkupPartition partition) {
		if (partition.getLength() == 0) {
			return null;
		}
		FontState fontState = new FontState(defaultState);
		boolean hasStyles = processStyles(partition.getBlock(), partition, fontState);

		if (partition.getBlock().getAttributes().getCssStyle() != null) {
			processCssStyles(fontState, defaultState, partition.getBlock().getAttributes().getCssStyle());
		} else {
			if (!hasStyles) {
				return null;
			}
		}
		StyleRange styleRange = styleManager.createStyleRange(fontState, 0, 1);

		TextAttribute textAttribute = createTextAttribute(styleRange);
		return new Token(fontState, textAttribute, partition.getOffset(), partition.getLength());
	}

	private boolean processStyles(Block block, MarkupPartition partition, FontState fontState) {
		boolean hasStyles = false;
		if (block.getParent() != null) {
			hasStyles = processStyles(block.getParent(), partition, fontState);
		}
		String cssStyles = computeCssStyles(block, partition);
		if (cssStyles != null) {
			hasStyles = true;
			processCssStyles(fontState, defaultState, cssStyles);
		}
		return hasStyles;
	}

	private String computeCssStyles(Block block, MarkupPartition partition) {
		String cssStyles = null;
		if (block.getHeadingLevel() > 0) {
			cssStyles = preferences.getCssByBlockModifierType()
					.get(Preferences.HEADING_PREFERENCES[block.getHeadingLevel()]);
		} else if (block.getType() != null) {
			String key = null;
			switch (block.getType()) {
			case CODE:
				key = Preferences.BLOCK_BC;
				break;
			case QUOTE:
				key = Preferences.BLOCK_QUOTE;
				break;
			case PREFORMATTED:
				key = Preferences.BLOCK_PRE;
				break;
			case DEFINITION_TERM:
				key = Preferences.BLOCK_DT;
				break;
			}
			cssStyles = preferences.getCssByBlockModifierType().get(key);
		}
		return cssStyles;
	}

	private void processCssStyles(FontState fontState, FontState parentState, String cssStyles) {
		Iterator<CssRule> ruleIterator = cssParser.createRuleIterator(cssStyles);
		while (ruleIterator.hasNext()) {
			styleManager.processCssStyles(fontState, parentState, ruleIterator.next());
		}
	}

	/**
	 * public for testing purposes
	 */
	public static class Token extends org.eclipse.jface.text.rules.Token {

		private final int offset;

		private final int length;

		private final FontState fontState;

		public Token(FontState fontState, TextAttribute attribute, int offset, int length) {
			super(attribute);
			this.fontState = fontState;
			if (offset < 0) {
				throw new IllegalArgumentException();
			}
			if (length < 0) {
				throw new IllegalArgumentException();
			}
			this.offset = offset;
			this.length = length;
		}

		public int getOffset() {
			return offset;
		}

		public int getLength() {
			return length;
		}

		public FontState getFontState() {
			return fontState;
		}

		@Override
		public TextAttribute getData() {
			return (TextAttribute) super.getData();
		}

		@Override
		public String toString() {
			return "Token [offset=" + offset + ", length=" + length + "]"; //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
		}

	}

}