/*
* Copyright (c) 2009 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:
*
*/

package com.nokia.testfw.stf.scripteditor.utils;

import static org.w3c.dom.Node.ELEMENT_NODE;

import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import org.w3c.dom.Document;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.SAXException;

public class Parser{

	/**
	 * Creates parser object based on location of xml file 
	 * @param xmlLocation
	 */
	public Parser(String xmlLocation) {

		this.sectionList = new ArrayList<SectionTag>();

		InputStream is = getClass().getResourceAsStream(xmlLocation);
		
		DocumentBuilderFactory builderFactory = DocumentBuilderFactory
				.newInstance();
		builderFactory.setNamespaceAware(true);
		builderFactory.setIgnoringElementContentWhitespace(true);

		DocumentBuilder builder = null;
		try {
			builder = builderFactory.newDocumentBuilder();
		} catch (ParserConfigurationException e) {
			e.printStackTrace();
		}
		Document xmlDoc = null;

		try {

			xmlDoc = builder.parse(is);

		} catch (SAXException e) {
			e.printStackTrace();

		} catch (IOException e) {
			e.printStackTrace();
		}

		Node rootNode = xmlDoc.getDocumentElement();

		NodeList list = rootNode.getChildNodes();

		for (int i = 0; i < list.getLength(); i++) {

			short typeC = list.item(i).getNodeType();
			if (typeC == ELEMENT_NODE) {

				Node sectionNode = list.item(i);
				SectionTag section = new SectionTag(list.item(i), 
						sectionNode.getAttributes().getNamedItem("name").getNodeValue(),
						sectionNode.getAttributes().getNamedItem("endname").getNodeValue(),
						sectionNode.getAttributes().getNamedItem("proposal").getNodeValue());
				sectionList.add(section);
			}
		}
	}
	
	/**
	 * Returns list of parsed sections 
	 */
	public ArrayList<SectionTag> gerSection() {
		return sectionList;
	}
	
	public SectionTag getSectionByName(String sectionName) {
		for (SectionTag tag : sectionList) {
			if (tag.getName().equals(sectionName)) {
				return tag;
			}
		}
		return null;
	}

	/**
	 * Returns list of commands from all section
	 * 
	 * @param Parser object
	 * @return ArrayList of strings - List of commands
	 * 	  
	 */
	public ArrayList<String> provideCommands() {

		ArrayList<SectionTag> arrayOfSections = this.gerSection();
		String[] sectionkeywrds = new String[arrayOfSections.size()];
		ArrayList<String> keywordsList = new ArrayList<String>();
		for (int i = 0; i < sectionkeywrds.length; i++) {

			SectionTag section = arrayOfSections.get(i);
			for (int g = 0; g < section.getCommandList().size(); g++) {

				String command = section.getCommandList().get(g)
						.getCommandName();
				keywordsList.add(command);
			}
		}
		return keywordsList;
	}

	private ArrayList<SectionTag> sectionList;

	/**
	 * first tier of tokenized line checking, gets proper command object type, and invokes mandatory argument checking 
	 * 
	 * @param tokenizedLine
	 * @param commandName
	 * @return
	 */

	public String checkArguments(ArrayList<String> tokenizedLine,
			String commandName) {

		ArrayList<SectionTag> arrayOfSections = this.gerSection();
		String[] sectionkeywrds = new String[arrayOfSections.size()];

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

			SectionTag section = arrayOfSections.get(i);
			for (int g = 0; g < section.getCommandList().size(); g++) {

				String command = section.getCommandList().get(g)
						.getCommandName();
				if (command.equals(commandName)) {
					boolean ret = checkMandatory(section.getCommandList()
							.get(g), tokenizedLine);
					if (!ret) {
						return section.getCommandList().get(g).getErrorNote();
					}
				}
			}
		}
		return null;
	}

	/**
	 * Checks mandatory arguments and invokes checking of optional arguments if needed
	 * 
	 * @param command - reference command parsed from XML file
	 * @param tokenizedLine - list containig arguments from editor (without command token)
	 * @return
	 */

	private boolean checkMandatory(Command command,	ArrayList<String> tokenizedLine) {
		ArrayList<String> ret = null;
		boolean optionalCheck;
		ArrayList<String> tokenizedMandatory = new ArrayList<String>();
		ArrayList<Arguments> argsList = command.getMandatory();
		ArrayList<Arguments> opionalList = command.getOptional();
		ArrayList<String> tokenizedOptional = new ArrayList<String>(
				tokenizedLine);

		int size = command.getMandatorySize();
		
		// conditions checked if command can not have arguments (ex. endloop)
		if(argsList.size()==0 && opionalList.size() == 0){
			if(tokenizedLine.size() ==0){
			return true;
			} else return false;
		}
		
		if (size > tokenizedLine.size()) {
			return false;
		}
		if (!tokenizedLine.isEmpty()) {
			for (int g = 0; g < tokenizedLine.size() && g < size; g++) {
				tokenizedMandatory.add(tokenizedLine.get(g));
				tokenizedOptional.remove(tokenizedLine.get(g));
			}
		}

		for (int i = 0; i < argsList.size(); i++) {

			ret = command.getMandatory().get(i).validate(tokenizedMandatory);
		}
		if (ret.size() == 0) {
			if (tokenizedOptional.size() == 0) {
				return true;
			}
			optionalCheck = checkOptional(opionalList, tokenizedOptional);
			if (optionalCheck) {
				return true;
			}
		}
		return false;
	}

	/**
	 * Checks optional arguments
	 * 	  
	 * @param opionalList - list of optional arguments parsed from XML
	 * @param optionalArgs - list of tokens remain after checking mandatory arguments 
	 * @return true if command contains valid optional arguments
	 */
	private boolean checkOptional(ArrayList<Arguments> optionalList,
			ArrayList<String> optionalArgs) {
		
		ArrayList<Arguments> tempOptionalList = new ArrayList<Arguments>(optionalList);

		for (int i = 0; i < tempOptionalList.size();) {
			int t = optionalArgs.size();
			optionalArgs = tempOptionalList.get(i).validate(optionalArgs);
			if (optionalArgs.size() != t) {
				tempOptionalList.remove(i);
				i = 0;
				continue;
			}
			i++;
		}
		if (optionalArgs.size() == 0) {
			return true;
		}
		return false;
	}
	
	/**
	 * 
	 * @return list of section tags
	 */
	public String[] provideSectionTags() {
		ArrayList<SectionTag> arrayOfSections = gerSection();
		String[] sectionkeywrds = new String[(arrayOfSections.size()*2)];
		int j = 0;
		for(int i = 0 ; (i < sectionkeywrds.length-1 && j < sectionkeywrds.length-1) ; i++ ){
			
			sectionkeywrds[j] = ("[" +arrayOfSections.get(i).getName() +"]");
			sectionkeywrds[++j] = ("[" +arrayOfSections.get(i).getEndName() +"]");
			j++;
			
		}
		return sectionkeywrds;	
	}
	public static ArrayList<String> provideMacrosObjects() {
		// TODO Auto-generated method stub
		return createdMacrosList;
	}
	
	public static ArrayList<String> provideObjectsList() {
		// TODO Auto-generated method stub
		return createdObjectsList;
	}
	
	public static ArrayList<String> createdMacrosList = new ArrayList<String>();
	public static ArrayList<String> createdObjectsList = new ArrayList<String>();
		
	
		
	
	
}