/*
 * Created on Jan 20, 2004
 */
package devs.speechpackage;
import javax.speech.*;
import javax.speech.recognition.*;
import java.io.FileReader;
import java.io.File;
import java.util.Locale;

/**
 * @author Martin Lukac
 */


public class SpeechRecognizer implements ResultListener{

	static Recognizer recognizer;
	
	public static void main(String [] args){
		
		new SpeechRecognizer();
	}
	
	
	/**
	 * the constructor of the recognizer implemented via Javax.speech.recognizer
	 */
	public SpeechRecognizer() {
		try{
			recognizer = Central.createRecognizer(new EngineModeDesc(Locale.ENGLISH));
			
			//Allocate the recognizer
			recognizer.allocate();
			
			//Load the grammar
			FileReader reader = new FileReader("gramm");
			RuleGrammar gram = recognizer.loadJSGF(reader);
			gram.setEnabled(true);
			
			//add listener
			recognizer.addResultListener(this);
			
			//commit the settings
			recognizer.commitChanges();
			
			//request focus
			recognizer.requestFocus();
			recognizer.resume();
			
			
		} catch (Exception e){
			e.printStackTrace();
		}

	}

	//running wwhen an item is recognized according to the grammar file 
	public void resultAccepted(ResultEvent e){
		Result r = (Result)(e.getSource());
		ResultToken tokens[] = r.getBestTokens();
		
		for (int a = 0;a < tokens.length; a++)
				System.out.print(tokens[a].getSpokenText() + " ");
		System.out.println();
		
		try {
			recognizer.deallocate();
		} catch (Exception ex){
			System.out.println("could not deallocate the synthesizer");
			//System.exit(0);
		}

	}

	//setting a rule for grammar
	public void updateRule(String ruleName, String [] data){
		sGrammar.setRule(ruleName, new RuleAlternatives(data), true);
	}
	
	//remove a rule from grammar
	public void updateRule(String ruleName){
		sGrammar.deleteRule(ruleName);
	}
	
	//get all rules names
	public String [] getRuleNames(){
		return sGrammar.listRuleNames();
	}

	//check for ewxistence of a rule name
	public boolean checkRuleName(String ruleName){
		String [] ruleNames = sGrammar.listRuleNames();
		for (int a = 0;a < ruleNames.length; a++)
			if (ruleNames[a] == ruleName)
				return true;
		return false;
	}

	// 
	/**
	 *	method adding grammar to the already existing one 
	 */
	public void addGrammar(File F){
		try{
			FileReader reader = new FileReader(F);
			RuleGrammar gram = recognizer.loadJSGF(reader);
			RuleName [] t = gram.listImports();
			
			for (int a = 0;a < t.length;a++)
				sGrammar.addImport(t[a]);
			
		} catch (Exception e){
			e.printStackTrace();
		}
	}

	/**
	 * removing existing imported grammar/rule
	 * @param name - the RuleName object to be removed
	 */
	public void delRule(RuleName name){
		sGrammar.removeImport(name);
	}

	/**
	 * 
	 * @return the result of translation
	 */
	public Result getResultState(){
		return getResultState();
	}
	
	/**
	 * 
	 * @return - returns the grammar in the case a result was identified
	 */
	public Grammar getGrammar(){
		return sGrammar;
	}
	
	/**
	 * 
	 * @return all loaded imported grammar rules
	 */
	public RuleName [] getAllGrammars(){
		return sGrammar.listImports();
	}
	
	public void resultinfoReleased(ResultEvent evt){
		System.out.println(evt.toString());
	}
	
	public void trainingInfoReleased(ResultEvent evt){
		System.out.println(evt.toString());
		
	}
	
	public void resultRejected(ResultEvent evt){
		System.out.println("sorry no identification occured");
	}
	
	public void grammarFinalized(ResultEvent evt){
		System.out.println(evt.toString());
		
	}
	
	public void audioReleased(ResultEvent evt){
		System.out.println(evt.toString());
		
	}
	
	public void resultUpdated(ResultEvent evt){
		System.out.println(evt.toString());
		
	}
	
	public void resultCreated(ResultEvent evt){
		System.out.println(evt.toString());
		
	}
	
	public void waitEngineState(long time){
		
	}
	
	//the recognizer engine
	private Recognizer sRecognizer;
	
	//the grammar currently loaded
	private RuleGrammar sGrammar;
}
