/*
    * Zemucan: A Syntax Assistant for DB2
    * Copyright (C) 2009, 2010 Andres Gomez Casanova
    *
    * This file is part of Zemucan.
    *
    * Zemucan is free software: you can redistribute it and/or modify
    * it under the terms of the GNU Lesser General Public License as published by
    * the Free Software Foundation; either version 3 of the License, or
   * (at your option) any later version.
   *
   * Zemucan is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   * GNU Lesser General Public License for more details.
   *
   * You should have received a copy of the GNU Lesser General Public License
   * along with this library; if not, see <http://www.gnu.org/licenses/>.
   *
   * Contact:
   * a n g o c a  at  y a h o o  dot  c o m
   * Cra. 45 No 61 - 31, Bogota, Colombia.
   *
   * Author:   $LastChangedBy: angoca $:
   * Date:     $LastChangedDate: 2011-03-06 22:24:44 -0500 (dom, 06 mar 2011) $:
   * Revision: $LastChangedRevision: 1915 $:
   * URL:      $HeadURL: https://zemucan.svn.sourceforge.net/svnroot/zemucan/branches/zemucan_v1/source-code/analyzers/src/main/java/name/angoca/zemucan/core/syntactic/impl/ImplementationSyntacticAnalyzer.java $:
   */
  package name.angoca.zemucan.core.syntactic.impl;
  
  import java.util.ArrayList;
  import java.util.Iterator;
  import java.util.List;
  
  import name.angoca.zemucan.AbstractZemucanException;
  import name.angoca.zemucan.core.graph.model.AbstractGraphNode;
  import name.angoca.zemucan.core.graph.model.GraphNode;
  import name.angoca.zemucan.core.graph.model.NonReservedGraphNode;
  import name.angoca.zemucan.core.graph.model.StartingNode;
  import name.angoca.zemucan.core.graph.model.TextualGraphNode;
  import name.angoca.zemucan.core.lexical.impl.InvalidTokenException;
  import name.angoca.zemucan.core.lexical.model.Token;
  import name.angoca.zemucan.core.syntactic.api.AbstractSyntacticAnalyzer;
  import name.angoca.zemucan.core.syntactic.model.GraphAnswer;
  import name.angoca.zemucan.grammarReader.api.GrammarReaderController;
  import name.angoca.zemucan.tools.Constants;
  import name.angoca.zemucan.tools.messages.Messages;
  
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  
  /**
   * This is the implementation of the syntax analyzer. This is almost the most
   * important part of the application. This class is not thread safe because it
   * does not have a synchronized part in the singleton.
   * <p>
   * Each node of the graph is unique, I mean there are not two nodes that
   * represents the same word. The grammar reader has to assure that there are not
   * this case in the produced graph.
   * <p>
   * <b>Control Version</b>
   * <p>
   * <ul>
   * <li>0.0.1 Class creation with first algorithm</li>
   * <li>0.0.2 Change the algorithm.</li>
   * <li>0.1.0 Throw exception when the graph is invalid.</li>
   * <li>0.2.0 Old algorithm deleted.</li>
   * <li>0.3.0 Recommendations from PMD.</li>
   * <li>0.3.1 Organized.</li>
   * <li>0.3.2 Instantiated object.</li>
   * <li>0.3.3 EndingToken not like an option.</li>
   * <li>0.3.4 InputSource for the XML file.</li>
   * <li>0.4.0 Invalid graph exception.</li>
   * <li>0.5.0 Destroy instance.</li>
   * <li>0.5.1 Starting and ending token as constants.</li>
   * <li>0.5.2 Logger messages.</li>
   * <li>0.5.3 Free resources when destroys the instance.</li>
   * <li>0.5.4 variable name and final.</li>
   * <li>1.0.0 Moved to version 1.</li>
   * <li>1.1.0 Exception hierarchy changed.</li>
   * <li>1.1.1 No null pointer exception.</li>
   * <li>1.2.0 Constructor visibility.</li>
   * <li>1.2.1 Not synchronized, not thread safe.</li>
   * <li>1.2.2 Destroy instance.</li>
   * <li>1.3.0 throws and asserts.</li>
   * <li>1.3.1 compareTo -> equals and TO DOs.</li>
   * <li>1.4.0 Space after phrase</li>
   * <li>1.4.1 GraphToken renamed by GraphNode</li>
   * <li>1.4.2 GrammarReader separated from graph.</li>
   * <li>1.4.3 Node renamed.</li>
   * <li>1.5.0 No delimiters and grammarController.</li>
   * <li>1.5.1 Synchronization.</li>
   * <li>1.6.0 Method renamed.</li>
   * <li>1.7.0 Without create token.</li>
   * <li>1.7.1 Iterator to analyze the ways.</li>
   * <li>1.7.2 Destroy grammar reader instance.</li>
   * <li>1.8.0 GraphNode hierarchy.</li>
   * </ul>
   *
  * @author Andres Gomez Casanova <a
  *         href="mailto:a n g o c a at y a h o o dot c o m" >(AngocA)</a>
  * @version 1.8.0 2010-08-29
  */
 public final class ImplementationSyntacticAnalyzer extends
 		AbstractSyntacticAnalyzer {
 
 	/**
 	 * The only instance of this object.
 	 */
 	private static ImplementationSyntacticAnalyzer instance;
 
 	/**
 	 * Logger.
 	 */
 	private static final Logger LOGGER = LoggerFactory
 			.getLogger(ImplementationSyntacticAnalyzer.class);
 
 	/**
 	 * Destroys the instance. Useful for testing purposes.
 	 */
 	public static void destroyInstance() {
 		ImplementationSyntacticAnalyzer.LOGGER
 				.debug("Destroying ImplementationSyntacticAnalyzer instance."); //$NON-NLS-1$
 
 		if (ImplementationSyntacticAnalyzer.instance != null) {
 			ImplementationSyntacticAnalyzer.instance.startingNode = null;
 			ImplementationSyntacticAnalyzer.instance = null;
 		}
 
 		assert ImplementationSyntacticAnalyzer.instance == null;
 	}
 
 	/**
 	 * Implementation of solitaire pattern, that returns the only instance of an
 	 * object.
 	 * <p>
 	 * This method has a part where it is synchronized, however it is not thread
 	 * safe because of the problem with the Single Pattern in Java
 	 * (http://www.ibm.com/developerworks/java/library/j-dcl.html)
 	 *
 	 * @return The only instance of this object.
 	 * @throws AbstractZemucanException
 	 *             When there is a problem at graph creation or a null
 	 *             parameter.
 	 */
 	public static ImplementationSyntacticAnalyzer/* ! */getInstance()
 			throws AbstractZemucanException {
 		if (ImplementationSyntacticAnalyzer.instance == null) {
 			ImplementationSyntacticAnalyzer.LOGGER
 					.debug("Creating ImplementationSyntaticAnalyzer instance."); //$NON-NLS-1$
 			synchronized (ImplementationSyntacticAnalyzer.class) {
 				ImplementationSyntacticAnalyzer.instance = new ImplementationSyntacticAnalyzer();
 			}
 		}
 
 		assert ImplementationSyntacticAnalyzer.instance != null;
 		return ImplementationSyntacticAnalyzer.instance;
 	}
 
 	/**
 	 * For assertions.
 	 */
 	private boolean assertsEnabled;
 
 	/**
 	 * This is the first token of the grammar, and all the commands are analyzed
 	 * from this token.
 	 */
 	private StartingNode startingNode;
 
 	/**
 	 * Constructor that sets a token that permits to scan the graph.
 	 *
 	 * @throws AbstractZemucanException
 	 *             When there is a problem when creating the graph. If there is
 	 *             a null parameter. When there is a problem reading the
 	 *             grammar. If there is a problem calling the GrammarReader.
 	 */
 	private ImplementationSyntacticAnalyzer() throws AbstractZemucanException {
 		super();
 		this.assertsEnabled = false;
 		// Intentional side-effect!
 		assert this.assertsEnabled = true;
 
 		this.startingNode = GrammarReaderController.getInstance()
 				.getStartingNode();
 		// Destroys the grammar reader controller instances because it is not
 		// longer necessary.
 		GrammarReaderController.destroyInstance();
 	}
 
 	/**
 	 * This method analyzes a set of options returned by the graph, and check
 	 * them if they start with the name of the given token but they don't
 	 * represent the same token in the graph (they are different strings).
 	 * <p>
 	 * This is the case of 'table' and 'tablespace', they are different but they
 	 * start with the same pattern.
 	 *
 	 * @param token
 	 *            Pattern token to search.
 	 * @param options
 	 *            Possible options to analyze.
 	 * @return Set of options that starts with the pattern token and it is
 	 *         different to the token.
 	 */
 	private List<Token>/* <!>! */analyzeOptions(final Token/* ! */token,
 			final List<Token>/* <!>! */options) {
 		assert token != null;
 		assert options != null;
 		if (this.assertsEnabled) {
 			for (final Token token2 : options) {
 				assert token2 != null;
 			}
 		}
 
 		final List<Token> ret = new ArrayList<Token>();
 		final String pattern = token.getToken().toLowerCase();
 		final int size = options.size();
 		for (int i = 0; i < size; i += 1) {
 			final Token option = options.get(i);
 
 			// Start with the same pattern, but it is not the same
 			// token option.
 			if (option.getToken().startsWith(pattern)
 					&& !option.getToken().equals(pattern)) {
 				if (option.getToken().equals(Constants.ENDING_NODE)) {
 					ImplementationSyntacticAnalyzer.LOGGER
 							.error(Messages
 									.getString("ImplementationSyntacticAnalyzer." //$NON-NLS-1$
 											+ "FatalError"), pattern); //$NON-NLS-1$
 					assert true;
 				}
 				ret.add(option);
 			}
 		}
 
 		assert ret != null;
 		if (this.assertsEnabled) {
 			for (final Token token3 : ret) {
 				assert token3 != null;
 			}
 		}
 		return ret;
 	}
 
 	/*
 	 * (non-Javadoc)
 	 *
 	 * @see name.angoca.zemucan.core.syntactic.api.AbstractSyntacticAnalyzer#
 	 * analyzeTokens(java.util.List, boolean)
 	 */
 	@Override
 	public GraphAnswer/* ! */analyzeTokens(final List<Token>/* <!>! */phrase,
 			final boolean endsWithSpace) throws AbstractZemucanException {
 		assert phrase != null;
 		if (this.assertsEnabled) {
 			for (final Token token : phrase) {
 				assert token != null;
 			}
 		}
 
 		// TODO v1.1 reducir el cyclomatic complexity
 		if (ImplementationSyntacticAnalyzer.LOGGER.isDebugEnabled()) {
 			ImplementationSyntacticAnalyzer.LOGGER.debug(
 					"Getting option: {}", phrase.toString()); //$NON-NLS-1$
 		}
 
 		// The search of the last node starts from the firsts node.
 		AbstractGraphNode currentNode = this.startingNode;
 
 		List<Token> lastValidOptions = new ArrayList<Token>(0);
 		List<Token> nextTokenOptions = new ArrayList<Token>(0);
 
 		final int size = phrase.size();
 		int index = -1;
 
 		// The search is still valid since there is a way in the
 		// graph. This means that the phrase is not recognized by the
 		// graph.
 		boolean valid = true;
 		// This is invariant of this cycle. (index <= size-1)
 		while ((index <= size - 1) && valid) {
 			// Evaluates if the currentNode is valid to find ways.
 			if (currentNode == null) {
 				this.optionNotFound(phrase, index);
 				valid = false;
 			} else {
 				// This is the case base that shows the possible
 				// options after the last token.
 				if (index == size - 1) {
 					index += 1;
 					nextTokenOptions = this.getWays(currentNode);
 
 				} else
 				// This is the other base case that shows the
 				// possibles options before the last token, and the
 				// options starts with the same name of the last
 				// token.
 				if (index == size - 2) {
 					index += 1;
 					final List<Token> lastTokenOptions = this
 							.getWays(currentNode);
 					final Token token = phrase.get(index);
 					if (!endsWithSpace) {
 						lastValidOptions = this.analyzeOptions(token,
 								lastTokenOptions);
 					}
 					currentNode = this.nextToken(currentNode, token);
 
 				} else
 				// This is the case when scanning the graph in order
 				// to search the last token.
 				if (index < size - 2) {
 					index += 1;
 					currentNode = this
 							.nextToken(currentNode, phrase.get(index));
 				}
 			}
 		}
 
 		final GraphAnswer graphAnswer = new GraphAnswer(lastValidOptions,
 				nextTokenOptions);
 		assert graphAnswer != null;
 		return graphAnswer;
 	}
 
 	/**
 	 * Returns all the possible ways from the current node. If EndingNode is
 	 * returned, that means that the current phrase is a valid command.
 	 * <p>
 	 * This creates a copy of the elements of the ways list.
 	 *
 	 * @param currentNode
 	 *            Current node to analyze.
 	 * @return The possible ways from the current node.
 	 * @throws InvalidTokenException
 	 *             If the graph token has an invalid token.
 	 */
 	private List<Token>/* <!>! */getWays(
 			final AbstractGraphNode/* ! */currentNode)
 			throws InvalidTokenException {
 		assert currentNode != null;
 
 		final Iterator<AbstractGraphNode> ways = currentNode.getWays();
 
 		final List<Token> ret = new ArrayList<Token>();
 
 		while (ways.hasNext()) {
 			final AbstractGraphNode graphNode = ways.next();
 			if (graphNode instanceof TextualGraphNode) {
 				if (graphNode instanceof NonReservedGraphNode) {
 					final NonReservedGraphNode nonReserved = (NonReservedGraphNode) graphNode;
 					ret.add(new Token(nonReserved.getName(), false));
 				} else if (graphNode instanceof GraphNode) {
 					final GraphNode reservedWordNode = (GraphNode) graphNode;
 					ret.add(new Token(reservedWordNode.getName(), true));
 				}
 			}
 		}
 
 		assert ret != null;
 		if (this.assertsEnabled) {
 			for (final Token token : ret) {
 				assert token != null;
 			}
 		}
 		return ret;
 	}
 
 	/**
 	 * This method scans the graph from the current currentNode, and searches
 	 * the token as one of its possible ways. If there is not a valid way in the
 	 * graph with the given token, the method return null.
 	 *
 	 * @param currentNode
 	 *            Node in the graph where the scan begins.
 	 * @param token
 	 *            Token to search as a possible way from the currentNode.
 	 * @return null if there is not a valid way from the current node, or a new
 	 *         node that represents the new position in the graph.
 	 */
 	private AbstractGraphNode/* ? */nextToken(
 			final AbstractGraphNode/* ! */currentNode,
 			final Token/* ! */token) {
 		assert currentNode != null;
 		assert token != null;
 
 		AbstractGraphNode ret = null;
 		final Iterator<AbstractGraphNode> ways = currentNode.getWays();
 
 		// This variable helps to stop the cycle when founding the
 		// valid token.
 		boolean found = false;
 
 		int count = 0;
 		while (ways.hasNext() && !found) {
 			final AbstractGraphNode temp = ways.next();
 			if (temp.represent(token.getToken())) {
 				ret = temp;
 				found = true;
 			}
 			// FireBugs says that is bogus, but I don't know why.
 			count += 1;
 		}
 
 		if (ImplementationSyntacticAnalyzer.LOGGER.isDebugEnabled()) {
 			if (ret == null) {
 				ImplementationSyntacticAnalyzer.LOGGER
 						.debug("Next: {}:\t{}->\tNULL", //$NON-NLS-1$
 								new String[] { token.toString(),
 										currentNode.toString() });
 			} else {
 				ImplementationSyntacticAnalyzer.LOGGER.debug(
 						"Next: {}:\t{}->\t{}", new String[] { //$NON-NLS-1$
 						token.toString(), currentNode.toString(),
 								ret.toString() });
 			}
 		}
 
 		return ret;
 	}
 
 	private void optionNotFound(final List<Token> phrase, final int index) {
 		if (ImplementationSyntacticAnalyzer.LOGGER.isDebugEnabled()) {
 			ImplementationSyntacticAnalyzer.LOGGER.debug(
 					"The '{}' option was not found in the grammar.", //$NON-NLS-1$
 					phrase.get(index).getToken());
 		}
 	}
 }