	package iitb.cfilt.cpost.vgi;

	import iitb.cfilt.cpost.ConfigReader;
	import iitb.cfilt.cpost.UTFWriter;
	import iitb.cfilt.cpost.ma.*;
	import iitb.cfilt.cpost.newstemmer.*;
	import iitb.cfilt.cpost.lexicon.*;
	import iitb.cfilt.cpost.tokenizer.TaggedTokenizer;
	import iitb.cfilt.cpost.utils.UTFConsole;
	import iitb.cfilt.cpost.taggen.*;

	import java.io.File;
import java.util.*;

	public class VerbGroup2 {

		private static VerbGroupIdentifierRuleReader vgr;

		private static UTFWriter ob;

		public VerbGroup2() {
			try {
				vgr = new VerbGroupIdentifierRuleReader();
				File outfile = new File(ConfigReader.get("VGI.VGMarkingFile"));
				if (outfile.exists()) {
					outfile.delete();
					outfile = new File(ConfigReader.get("VGI.VGMarkingFile"));
				}
				ob = new UTFWriter(outfile);
			} catch (Exception e) {
				System.out.println(e.toString());
				e.printStackTrace();
			}
		}

/* *************************************************************************************** */
/*Nikhilesh Sharma		
Method : "identifyVerbGroups"
Psudo-code :
Go from left to right 
only for words having VM/VAux in catagery list

If ( current_suffix/word IN must_end_suffix/word_List or isLastWord )
	End VG here
else if( next_word is Non_Verb )
			End VG here	
else if( suffix exists )
		if( "suffix next_word" IN Adv_suffix_word_list)   // "suffix nwxt_word" like "ते हुए", "ती हुई"
			End VG here
		if( VGContinue )  // check if its not main verb in current VG //
			if ( next_word IN next_word_list(suffix) )
				Continue VG		
			else if( suffix is Adv_Suffixes )
				End VG here
			else
				Abort VG
		else    // Its main verb
			if( suffix is Adv_Suffixes )
				End VG here
			else
				Start VG
else 
	if( VGContinue )	// check if its not main verb in current VG //
		if( next_root_word in next_word_list(word) )
			Continue VG
		else if( word IN Adv_words)
			Ens VG here
		else
			Abort VG
	else     // Its main verb
		Start VG
  
 */		
		
/* *************************************************************************************** */
		
		public Vector<MorphologicallyAnalyzedToken> identifyVerbGroups1(
				Vector<MorphologicallyAnalyzedToken> matv) {
			// Vector<Integer> vgi = new Vector<Integer>();
			int[] vgi = new int[matv.size()];
			int currentVGstartedAt = 0;
			int VGnumber = 1;
			//String last = new String();
			boolean ContinueVG = false;
			for (int i = 0; i < matv.size(); i++) {
				vgi[i] = 0;
				String token = matv.get(i).getToken();
				System.out.println("Working for " + token);				
				if (matv.get(i).getStemmedOutputs() != null
						&& matv.get(i).getStemmedOutputs().size() > 0
						&& matv.get(i).getStemmedOutputs().get(0).getCategory()
								.trim().equals("SYM")) {
					vgi[i] = 0;
					 System.out.println("SYM");				
					continue;
				}
				if (matv.get(i).getStemmedOutputs() != null
						&& matv.get(i).getStemmedOutputs().size() > 0
						&& (matv.get(i).getAmbiguityScheme().contains("verb") || matv
								.get(i).getAmbiguityScheme().contains("verb_aux"))) {					
					if(ContinueVG == false){
						currentVGstartedAt = i;
					}
					System.out.println("Start VG.1");
					vgi[i] = 1;//VGnumber;
					VGnumber = 2;//++
					currentVGstartedAt = i;			
					ContinueVG = true;
					//for(int vg = i; true; vg++){
						
					for (int j = 0; j < matv.get(i).getStemmedOutputs().size(); j++) {					
						
						StemmerRuleResult srr = matv.get(i).getStemmedOutputs().get(j);
						boolean endWord = vgr.mustEndWords.contains(srr.getRoot());
						boolean isVerb = isVerb(srr);
						boolean isVerbAux = isVerbAux(srr);
						boolean endSuffix = vgr.mustEndSuffixes.contains(srr.getSuffixList().get(0));
						boolean isLastWordofSentence = ( i == matv.size()-1 );
						
						if ((endWord || endSuffix || isLastWordofSentence) && (isVerb || isVerbAux)) {
							/* End VG */												
						}						
						else if(!isLastWordofSentence && (isVerb || isVerbAux)){
							boolean isNextVerbAux = false, isNextVerb = false;
							isNextVerb = matv.get(i + 1).getAmbiguityScheme().contains("verb");
							isNextVerbAux = matv.get(i + 1).getAmbiguityScheme().contains("verb_aux");
							if (!isNextVerbAux) {
								if(isNextVerb){
									/* check suffix agreement */
									if(agree(srr, matv.get(i+1))){
										/* Continue */
									}
									else{
										/* Abort */
									}
								}
								else{
									/* End */
								}
							}
							else if(hasSuffix(srr) && vgr.hasAdverbialSuffix_Word(srr.getSuffixList().get(0)) && vgr.getNextAdverbial(srr.getSuffixList().get(0)).equals(matv.get(i+1).getToken())){
								
							}
						}
					}
			}
		}
		
									
		for (int i = 0; i < vgi.length; i++) {
			System.out.print(vgi[i] + "\t");
		}
		// System.out.println("Last "+ last);
		return matv;
	}

boolean hasSuffix(StemmerRuleResult srr){
	boolean retval = false;
	retval = srr.getSuffixList().size()>0 && !(srr.getSuffixList().get(0).isEmpty()); 
	return retval;
}

boolean isVerb(StemmerRuleResult srr){
	boolean retval = false;
	retval = srr.getCategory().equals("verb"); 
	return retval;
}

boolean isVerbAux(StemmerRuleResult srr){
	boolean retval = false;
	retval = srr.getCategory().equals("verb_aux"); 
	return retval;
}

boolean agree(StemmerRuleResult srr, MorphologicallyAnalyzedToken mat){
	boolean retval = false;
	for(int i = 0; i<mat.getStemmedOutputs().size(); i++){
		if(mat.getStemmedOutputs().get(i).getSuffixList().contains(srr.getSuffixList().get(0))){
			retval = true;
			break;
		}
	}
	return retval;
}
		public static void main(String args[]) {
			ConfigReader.read(args[0]);
			Stemmer stemmer = new Stemmer();
			VerbGroup2 vb = new VerbGroup2();
			Vector<StemmedToken> stemmedTokens = new Vector<StemmedToken>();
			Vector<MorphologicallyAnalyzedToken> maTokens = new Vector<MorphologicallyAnalyzedToken>();
			String sentence = "राम खाते हुए भागा ";//"राम कर चुका देगा";//"राम कर चुका होगा";//"राम खाते हुए भागा ";//"राम को खाते रहना पड़ता है";//"आप खाना खाकर ही जाना";//"राम यह काम कर रहा होगा";//"राम करता रह सकता था";// "राम खाना खाता और चला जाता है";// "राम जाना जाता है";//
														// 
			String tokens[] = sentence.split(" ");
			List l = Arrays.asList(tokens);
			Vector<String> tokenList = new Vector<String>(l);
			// System.out.println(tokenList.toString());
			MorphologicalAnalyzerRuleReader MAR = new MorphologicalAnalyzerRuleReader();
			MorphologicalAnalyzer ma = new MorphologicalAnalyzer();
			stemmedTokens = stemmer.stem(tokenList);
			/*
			 * for (int i = 0; i < stemmedTokens.size(); i++) {
			 * System.out.println(stemmedTokens.get(i).getStemmedOutputs()
			 * .toString()); }
			 */
			maTokens = ma.analyze(stemmedTokens);
			/*
			 * for (int i = 0; i < maTokens.size(); i++) {
			 * System.out.println(maTokens.get(i).getAmbiguityScheme().toString()); }
			 */
			maTokens = vb.identifyVerbGroups1(maTokens);
			/*
			 * for(int i=0; i<tokens.length; i++){ StemmedToken stemmedToken =
			 * stemmer.stem(tokens[i]); MorphologicallyAnalyzedToken mat =
			 * ma.analyze(stemmedToken,MAR); }
			 */
		}
	}

