/FileExtraction/Java_unseen/slavpetrov_berkeleyparser/src/edu/berkeley/nlp/conll/DepToPTB.java
/**
 * 
 */
package edu.berkeley.nlp.conll;

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.InputStreamReader;
import java.nio.charset.Charset;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;

import edu.berkeley.nlp.PCFGLA.Option;
import edu.berkeley.nlp.PCFGLA.OptionParser;
import edu.berkeley.nlp.syntax.Tree;

/**
 * @author petrov
 * 
 */
public class DepToPTB {

	public static class Options {

		@Option(name = "-in", required = true, usage = "Input File for Grammar (Required)")
		public String inFileName;

		@Option(name = "-finePOStags", usage = "Use fine POS tags (Default: false=coarse")
		public boolean useFinePOS = false;

	}

	public static void main(String[] args) {
		// String[] sentence = {
		// "1 The _ DT DT _ 4 NMOD _ _\n",
		// "2 luxury _ NN NN _ 4 NMOD _ _\n",
		// "3 auto _ NN NN _ 4 NMOD _ _\n",
		// "4 maker _ NN NN _ 7 SBJ _ _\n",
		// "5 last _ JJ JJ _ 6 NMOD _ _\n",
		// "6 year _ NN NN _ 7 VMOD _ _\n",
		// "7 sold _ VB VBD _ 0 ROOT _ _\n",
		// "8 1,214 _ CD CD _ 9 NMOD _ _\n",
		// "9 cars _ NN NNS _ 7 OBJ _ _\n",
		// "10 in _ IN IN _ 7 ADV _ _\n",
		// "11 the _ DT DT _ 12 NMOD _ _\n",
		// "12 U.S. _ NN NNP _ 10 PMOD _ _\n"};
		OptionParser optParser = new OptionParser(Options.class);
		Options opts = (Options) optParser.parse(args, true);
		// provide feedback on command-line arguments
		// System.out.println("Calling with " + optParser.getPassedInOptions());

		BufferedReader input = null;
		String fileName = opts.inFileName;
		try {
			input = new BufferedReader(new InputStreamReader(
					new FileInputStream(fileName), Charset.forName("UTF-8")));// GB18030")));
			String line = "";
			List<String> sentence = new ArrayList<String>();
			while ((line = input.readLine()) != null) {
				System.out.println(line);
				if (line.equals("")) {
					Tree<String> tree = turnIntoTree(sentence, opts.useFinePOS);
					System.out.println("( " + tree + ")");
					sentence = new LinkedList<String>();
				} else
					sentence.add(line);
			}

		} catch (Exception ex) {
			ex.printStackTrace();
		}

	}

	/**
	 * @param sentence
	 * @return
	 */
	private static Tree<String> turnIntoTree(List<String> sentence,
			boolean useFinePOS) {
		int posIndex = (useFinePOS) ? 4 : 3;
		int nWords = sentence.size();
		Tree[] trees = new Tree[nWords];
		List<Integer>[] childIndices = new List[nWords];
		int[] freeKids = new int[nWords];
		int[] parentIndices = new int[nWords];
		int rootIndex = -1;

		for (int i = 0; i < nWords; i++) {
			childIndices[i] = new LinkedList<Integer>();
		}

		for (int i = 0; i < nWords; i++) {
			String[] fields = sentence.get(i).split("\t");
			String word = fields[1];
			if (word.equals("(") || word.equals(")"))
				word = "LRB";
			Tree<String> child = new Tree<String>(word);
			List<Tree<String>> childList = new ArrayList<Tree<String>>(1);
			childList.add(child);
			String tag = fields[posIndex];
			if (tag.equals("(") || tag.equals(")"))
				tag = "LRB";
			trees[i] = new Tree<String>(tag, childList);
			int pIndex = Integer.parseInt(fields[6]) - 1;
			parentIndices[i] = pIndex;
			if (pIndex == -1)
				rootIndex = i;
			else
				childIndices[pIndex].add(i);
			childIndices[i].add(i);
		}

		if (nWords == 1)
			return trees[0];

		for (int i = 0; i < nWords; i++) {
			for (Integer c : childIndices[i]) {
				if (childIndices[c].size() == 1)
					freeKids[i]++;
			}
			freeKids[i]++; // because each tree is also its own child
		}

		while (childIndices[rootIndex].size() > 0) {
			for (int i = 0; i < nWords; i++) {
				if (childIndices[i].size() <= 1)
					continue;
				if (freeKids[i] == childIndices[i].size()) { // all its children
																// are free ->
																// attach them
					List<Tree<String>> childList = new ArrayList<Tree<String>>();
					for (Integer c : childIndices[i]) {
						childList.add(trees[c]);
					}
					Tree<String> newTree = new Tree<String>(trees[i].getLabel()
							+ "*", childList);
					trees[i] = newTree;
					if (parentIndices[i] >= 0)
						freeKids[parentIndices[i]]++;
					childIndices[i] = new LinkedList();
				}
			}
		}
		return trees[rootIndex];
	}

}
