/*

 * Copyright (c) 2007-2010 Nokia Corporation and/or its subsidiary(-ies). 

 * All rights reserved.

 * This component and the accompanying materials are made available

 * under the terms of "Eclipse Public License v1.0"

 * which accompanies this distribution, and is available

 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

 *

 * Initial Contributors:

 * Nokia Corporation - initial contribution.

 *

 * Contributors:

 *

 * Description:

 *

 * Parses the rule text field for validity

 *

 */

package com.nokia.traceviewer.dialog;

import java.util.ArrayList;

import java.util.Collections;

import java.util.Comparator;

import java.util.List;

import org.eclipse.swt.SWT;

import org.eclipse.swt.custom.StyleRange;

import org.eclipse.swt.custom.StyledText;

import org.eclipse.swt.events.FocusEvent;

import org.eclipse.swt.events.FocusListener;

import org.eclipse.swt.events.KeyEvent;

import org.eclipse.swt.events.KeyListener;

import org.eclipse.swt.events.MouseEvent;

import org.eclipse.swt.events.MouseListener;

import org.eclipse.swt.graphics.Color;

import org.eclipse.swt.graphics.Point;

import org.eclipse.swt.widgets.TreeItem;

import com.nokia.traceviewer.engine.TraceViewerGlobals;

import com.nokia.traceviewer.engine.dataprocessor.FilterRuleSet.LogicalOperator;

/**

 * Parses the rule text field for validity

 */

public final class FilterAdvancedParser implements FocusListener, KeyListener,

		MouseListener {

	/**

	 * Indicates the max number of brackets in a rule. Used to shut down while

	 * loop if there is something wrong

	 */

	private static final int MAX_NUMBER_OF_BRACKETS = 50;

	/**

	 * AND String

	 */

	public static final String AND = "AND"; //$NON-NLS-1$

	/**

	 * OR String

	 */

	public static final String OR = "OR"; //$NON-NLS-1$

	/**

	 * NOT String

	 */

	public static final String NOT = "NOT"; //$NON-NLS-1$

	/**

	 * Start bracket

	 */

	private static final char START_BRACKET = '(';

	/**

	 * Start bracket String

	 */

	public static final String START_BRACKET_STR = "("; //$NON-NLS-1$

	/**

	 * End bracket

	 */

	private static final char END_BRACKET = ')';

	/**

	 * End bracket String

	 */

	public static final String END_BRACKET_STR = ")"; //$NON-NLS-1$

	/**

	 * Space

	 */

	public static final char SPACE = ' ';

	/**

	 * Space String

	 */

	public static final String SPACE_STR = " "; //$NON-NLS-1$

	/**

	 * Empty String

	 */

	private static final String EMPTY = ""; //$NON-NLS-1$

	/**

	 * Text field to validate

	 */

	private final StyledText textField;

	/**

	 * Rule items

	 */

	private final TreeItem[] items;

	/**

	 * Blue color

	 */

	private final Color blue;

	/**

	 * Gray color

	 */

	private final Color gray;

	/**

	 * Constructor

	 * 

	 * @param ruleTextfield

	 *            rule text field

	 * @param items

	 *            rule items

	 */

	public FilterAdvancedParser(StyledText ruleTextfield, TreeItem[] items) {

		textField = ruleTextfield;

		this.items = items;

		blue = textField.getDisplay().getSystemColor(SWT.COLOR_BLUE);

		gray = textField.getDisplay().getSystemColor(SWT.COLOR_GRAY);

	}

	/*

	 * (non-Javadoc)

	 * 

	 * @see

	 * org.eclipse.swt.events.KeyListener#keyPressed(org.eclipse.swt.events.

	 * KeyEvent)

	 */

	public void keyPressed(KeyEvent e) {

		if (e.keyCode != SWT.CTRL) {

			validate();

			// Set button states

			TraceViewerGlobals.getTraceViewer().getDataProcessorAccess()

					.getFilterProcessor().getFilterDialog().getAdvancedDialog()

					.setButtonStates();

		}

	}

	/*

	 * (non-Javadoc)

	 * 

	 * @seeorg.eclipse.swt.events.MouseListener#mouseUp(org.eclipse.swt.events.

	 * MouseEvent)

	 */

	public void mouseUp(MouseEvent e) {

		if (textField.getText().length() > 1) {

			Point selection = null;

			if (textField.getSelectionRange().y > 0) {

				selection = textField.getSelection();

			}

			validate();

			// Set button states

			TraceViewerGlobals.getTraceViewer().getDataProcessorAccess()

					.getFilterProcessor().getFilterDialog().getAdvancedDialog()

					.setButtonStates();

			if (selection != null) {

				textField.setSelection(selection);

			}

		}

	}

	/**

	 * Validates the text field

	 */

	void validate() {

		textField.getCaret().setVisible(false);

		String text = textField.getText();

		// Change logical operations to upper case

		text = text.replace(" and ", SPACE + AND + SPACE); //$NON-NLS-1$

		text = text.replace(" or ", SPACE + OR + SPACE); //$NON-NLS-1$

		text = text.replace(" not ", SPACE + NOT + SPACE); //$NON-NLS-1$

		StringBuffer newText = new StringBuffer(text);

		int caretPos = textField.getCaretOffset();

		int removedBeforeCaret = removeDoubleSpaces(newText, caretPos);

		caretPos -= removedBeforeCaret;

		// Empty, add one space

		if (newText.length() == 0) {

			newText.append(SPACE);

			caretPos = 1;

		}

		// Insert the text and color the caret

		textField.setText(newText.toString());

		textField.setCaretOffset(caretPos);

		colorCaretAndRules();

		textField.getCaret().setVisible(true);

	}

	/**

	 * Removes double spaces

	 * 

	 * @param newText

	 *            StringBuffer to use

	 * @param caretPos

	 *            old caret position

	 * @return number of chars removed before caret position

	 */

	private int removeDoubleSpaces(StringBuffer newText, int caretPos) {

		int charsRemoved = 0;

		boolean lastCharSpace = false;

		for (int i = 0; i < newText.length(); i++) {

			if (newText.charAt(i) == SPACE) {

				if (lastCharSpace) {

					newText.deleteCharAt(i);

					if (i < caretPos) {

						charsRemoved++;

					}

					i--;

				}

				lastCharSpace = true;

			} else {

				lastCharSpace = false;

			}

		}

		return charsRemoved;

	}

	/**

	 * Counts occurrences of a character from a string

	 * 

	 * @param text

	 *            text to find from

	 * @param c

	 *            the character

	 * @return number of occurrences in the string

	 */

	private int countOccurrences(String text, char c) {

		int occ = 0;

		for (int i = 0; i < text.length(); i++) {

			if (text.charAt(i) == c) {

				occ++;

			}

		}

		return occ;

	}

	/**

	 * Colors the caret and the rules

	 */

	private void colorCaretAndRules() {

		List<StyleRange> ranges = new ArrayList<StyleRange>();

		int caretPos = textField.getCaretOffset();

		// Color the rules

		if (items != null) {

			String text = textField.getText();

			text = text.replace(START_BRACKET, SPACE);

			text = text.replace(END_BRACKET, SPACE);

			StringBuffer buf = new StringBuffer();

			ArrayList<String> words = new ArrayList<String>();

			ArrayList<Integer> offsets = new ArrayList<Integer>();

			// Gather the words

			for (int i = 0; i < text.length(); i++) {

				char c = text.charAt(i);

				if (c == SPACE) {

					// If the buffer is not empty, it's a word and should be

					// added to the list

					if (!buf.toString().replace(SPACE_STR, EMPTY).equals(EMPTY)) {

						words.add(buf.toString());

						offsets.add(Integer.valueOf(i - buf.length()));

					}

					buf.setLength(0);

				} else {

					buf.append(c);

				}

			}

			// Create the style ranges for the basic rules found

			for (int j = 0; j < words.size(); j++) {

				if (isBasicRule(words.get(j))) {

					ranges.add(new StyleRange(offsets.get(j).intValue(), words

							.get(j).length(), blue, null));

				}

			}

		}

		// Color the caret if not focused

		if (!textField.isFocusControl()) {

			if (caretPos > textField.getCharCount()) {

				caretPos = textField.getCharCount();

			}

			ranges.add(new StyleRange(caretPos - 1, 1, gray, gray));

		}

		// Sort and set the ranges

		ranges = sortColorRanges(ranges);

		textField.setStyleRanges(ranges.toArray(new StyleRange[ranges.size()]));

	}

	/**

	 * Sorts color ranges

	 * 

	 * @param ranges

	 *            color ranges

	 * @return ordered list

	 */

	private List<StyleRange> sortColorRanges(List<StyleRange> ranges) {

		Collections.sort(ranges, new Comparator<StyleRange>() {

			public int compare(StyleRange o1, StyleRange o2) {

				int id1 = o1.start;

				int id2 = o2.start;

				return id1 > id2 ? 1 : id1 < id2 ? -1 : 0;

			}

		});

		return ranges;

	}

	/**

	 * Finds and returns a set from caret pos

	 * 

	 * @param text

	 *            text to search from

	 * @param caretOffset

	 *            caret offset

	 * @return the set where the caret is on

	 */

	private String findSet(String text, int caretOffset) {

		String set = null;

		if (text.length() > 0) {

			// Get counts for the brackets

			int startCount = countOccurrences(text.substring(0, caretOffset),

					START_BRACKET);

			int endCount = countOccurrences(text.substring(0, caretOffset),

					END_BRACKET);

			// Full sets before the caret, start from last end bracket

			if (startCount == endCount) {

				// Get indices for the nearest brackets

				int startIdx = getNearestChar(text, caretOffset, START_BRACKET,

						true);

				int endIdx = getNearestChar(text, caretOffset, END_BRACKET,

						false);

				if (startIdx == -1) {

					startIdx = text.length();

				}

				if (endIdx == -1) {

					endIdx = 0;

				} else {

					endIdx++;

				}

				set = text.substring(endIdx, startIdx);

			} else {

				// Get indices for the nearest brackets

				int startIdx = getNearestChar(text, caretOffset, START_BRACKET,

						false);

				int endIdx = getNearestChar(text, caretOffset, END_BRACKET,

						true);

				if (startIdx == -1) {

					startIdx = 0;

				} else {

					startIdx++;

				}

				if (endIdx == -1) {

					endIdx = text.length();

				}

				set = text.substring(startIdx, endIdx);

			}

		}

		return set;

	}

	/**

	 * Gets nearest char from a string

	 * 

	 * @param text

	 *            text to search from

	 * @param caretOffset

	 *            caret offset

	 * @param c

	 *            character to search for

	 * @param forward

	 *            forward or backward search

	 * @return offset of nearest character. -1 if not found

	 */

	private int getNearestChar(String text, int caretOffset, char c,

			boolean forward) {

		int idx = -1;

		// Searching forwards

		if (forward) {

			idx = text.indexOf(c, caretOffset);

			// Searching backwards

		} else if (text.length() > 0) {

			for (int i = caretOffset - 1; i >= 0; i--) {

				if (text.charAt(i) == c) {

					idx = i;

					break;

				}

			}

		}

		return idx;

	}

	/**

	 * Tells if a set is open

	 * 

	 * @return true if set is open

	 */

	boolean isSetOpen() {

		boolean setOpen = false;

		int startCount = countOccurrences(textField.getText(), START_BRACKET);

		int endCount = countOccurrences(textField.getText(), END_BRACKET);

		if (startCount > endCount) {

			setOpen = true;

		}

		return setOpen;

	}

	/**

	 * Check if AND can be inserted to current pos

	 * 

	 * @return true if AND can be inserted

	 */

	boolean canAndBeInserted() {

		boolean canBeInserted = true;

		String set = findSet(textField.getText(), textField.getCaretOffset());

		// If there is OR

		if (set != null && set.contains(OR)) {

			canBeInserted = false;

		} else if (set != null && !containsFilterRule(set, items)

				&& !isSetOpen()

				&& !containsFilterRule(textField.getText(), items)) {

			canBeInserted = false;

		} else if (set != null && !containsFilterRule(set, items)

				&& isSetOpen()) {

			canBeInserted = false;

		} else if (set == null) {

			canBeInserted = false;

		}

		return canBeInserted;

	}

	/**

	 * Check if OR can be inserted to current pos

	 * 

	 * @return true if OR can be inserted

	 */

	boolean canOrBeInserted() {

		boolean canBeInserted = true;

		String set = findSet(textField.getText(), textField.getCaretOffset());

		// If there is AND

		if (set != null && set.contains(AND)) {

			canBeInserted = false;

		} else if (set != null && !containsFilterRule(set, items)

				&& !isSetOpen()

				&& !containsFilterRule(textField.getText(), items)) {

			canBeInserted = false;

		} else if (set != null && !containsFilterRule(set, items)

				&& isSetOpen()) {

			canBeInserted = false;

		} else if (set == null) {

			canBeInserted = false;

		}

		return canBeInserted;

	}

	/**

	 * Check if new set can be started to current pos

	 * 

	 * @return true if new set can be started

	 */

	boolean canNewSetBeStarted() {

		boolean canBeStarted = false;

		String text = textField.getText();

		int caretPos = textField.getCaretOffset();

		boolean ready = false;

		StringBuffer buf = new StringBuffer();

		// Text has to contain at least one rule

		if (containsFilterRule(text, items) && caretPos > 1) {

			// Go backwards and check the previous word

			for (int i = caretPos - 1; i > 0; i--) {

				char c = text.charAt(i);

				// Space, do nothing

				if (c == SPACE) {

					if (ready) {

						// Remove NOT

						if (buf.toString().equals(NOT)) {

							buf.setLength(0);

							ready = false;

						} else {

							break;

						}

					}

				} else {

					buf.insert(0, c);

					ready = true;

				}

			}

			String word = buf.toString();

			if (word.contains(OR) || word.contains(AND)) {

				canBeStarted = true;

			}

		} else {

			canBeStarted = true;

		}

		return canBeStarted;

	}

	/**