private static final Logger LOGGER = LoggerFactory.getLogger(ECBPlusEvaluator.class);
    private static final Pattern tokenPattern = Pattern.compile(".*/([0-9]+)_([0-9]+ecb[a-z]*)\\.xml#char=([0-9]+).*");
    private static final Pattern fileNamePattern = Pattern.compile("[0-9]+/([0-9]+)_([0-9a-zA-Z]+)");

    //    private static final Boolean removeAloneClusters = false;
//    private static final Pattern chainPattern = Pattern.compile("CHAIN=\"([0-9]+)\"");
    private static Integer FOLDER = null;

    public static void printToken(Appendable writer, Term token, int i, String last) throws IOException {
        writer.append(String.format("%d", i)).append("\t");
        writer.append(token.getForm()).append("\t");
        writer.append("_").append("\t");
        writer.append(token.getForm()).append("\t");
        writer.append("_").append("\t");
        writer.append(token.getMorphofeat()).append("\t");
        writer.append("_").append("\t");
        writer.append("_").append("\t");
        writer.append("_").append("\t");
        writer.append("_").append("\t");
        writer.append("_").append("\t");
        writer.append("_").append("\t");
        writer.append("_").append("\t");
        writer.append("_").append("\t");
        writer.append("_").append("\t");
        writer.append("_").append("\t");
        writer.append(last);
        writer.append("\n");

    }

    public static void main(String[] args) {
        try {

            final CommandLine cmd = CommandLine
                    .parser()
                    .withName("./ecb-evaluator")
                    .withHeader("Evaluator event extractor")
                    .withOption("n", "input-naf", "Input NAF folder", "FOLDER",
                            CommandLine.Type.DIRECTORY_EXISTING, true, false, true)
                    .withOption("i", "input-csv", "Input CSV file", "FILE",
                            CommandLine.Type.FILE_EXISTING, true, false, true)
                    .withOption("g", "output-gold", "Output gold file", "FILE",
                            CommandLine.Type.FILE, true, false, true)
                    .withOption("b", "output-baseline", "Output baseline file", "FILE",
                            CommandLine.Type.FILE, true, false, true)
                    .withOption("o", "output", "Output file", "FILE",
                            CommandLine.Type.FILE, true, false, true)
                    .withOption("l", "input-lemmas", "Lemmas CSV file", "FILE",
                            CommandLine.Type.FILE_EXISTING, true, false, false)
                    .withOption("a", "input-all-lemmas", "Lemmas CSV file", "FILE",
                            CommandLine.Type.FILE_EXISTING, true, false, false)
//                    .withOption("r", "remove-alone", "Remove alone clusters")
                    .withOption("c", "check-gold", "Use only events annotated in gold standard")
                    .withOption("s", "add-single", "Add single clusters")
                    .withLogger(LoggerFactory.getLogger("eu.fbk")).parse(args);

            File inputCsv = cmd.getOptionValue("input-csv", File.class);
            File inputNaf = cmd.getOptionValue("input-naf", File.class);
            File inputLemmas = cmd.getOptionValue("input-lemmas", File.class);
            File inputAllLemmas = cmd.getOptionValue("input-all-lemmas", File.class);

            File outputGold = cmd.getOptionValue("output-gold", File.class);
            File outputBaseline = cmd.getOptionValue("output-baseline", File.class);
            File output = cmd.getOptionValue("output", File.class);

//            Boolean removeAloneClusters = cmd.hasOption("remove-alone");
            Boolean checkGold = cmd.hasOption("check-gold");
            Boolean addSingleClusters = cmd.hasOption("add-single");

            Reader in;
            Iterable<CSVRecord> records;

            HashMap<String, Integer> lemmas = null;
            HashMap<String, Integer> allLemmas = null;

            int lemmaIndex = 0;
            if (inputLemmas != null) {
                lemmas = new HashMap<>();
                in = new FileReader(inputLemmas);
                records = CSVFormat.EXCEL.withHeader().parse(in);
                for (CSVRecord record : records) {
                    String lemma = record.get(1);
                    lemma = lemma.replaceAll("\"", "").trim();
                    if (lemma.length() > 0) {
                        lemmas.put(lemma, ++lemmaIndex);
                    }
                }
            }
            lemmaIndex = 0;
            if (inputAllLemmas != null) {
                allLemmas = new HashMap<>();
                in = new FileReader(inputAllLemmas);
                records = CSVFormat.EXCEL.withHeader().parse(in);
                for (CSVRecord record : records) {
                    String lemma = record.get(1);
                    lemma = lemma.replaceAll("\"", "").trim();
                    if (lemma.length() > 0) {
                        allLemmas.put(lemma, ++lemmaIndex);
                    }
                }
            }

            if (lemmas != null) {
                LOGGER.info("Lemmas: {}", lemmas.size());
            }
            if (allLemmas != null) {
                LOGGER.info("All-lemmas: {}", allLemmas.size());
            }

            BufferedWriter goldWriter = new BufferedWriter(new FileWriter(outputGold));
            BufferedWriter baselineWriter = new BufferedWriter(new FileWriter(outputBaseline));
            BufferedWriter writer = new BufferedWriter(new FileWriter(output));

            HashMultimap<String, String> goldTmpClusters = HashMultimap.create();
            HashMap<String, String> goldClusters = new HashMap<>();
            Set<String> okEvents = new HashSet<>();

            Map<String, String> theBaseline = new HashMap<>();

            for (final File file : Files.fileTreeTraverser().preOrderTraversal(inputNaf)) {
                if (!file.isFile()) {
                    continue;
                }
                if (file.getName().startsWith(".")) {
                    continue;
                }

                String path = file.getParentFile().toString();
                String relativeFilePath = file.getAbsolutePath()
                        .substring(inputNaf.getAbsolutePath().length());

                Matcher matcher = fileNamePattern.matcher(relativeFilePath);
                Integer folder = null;
                String fileNum = null;
                if (matcher.find()) {
                    folder = Integer.parseInt(matcher.group(1));
                    fileNum = matcher.group(2);

                } else {
                    LOGGER.error("Error in file name: {}", relativeFilePath);
                    System.exit(1);
                }

                if (FOLDER != null && !folder.equals(FOLDER)) {
                    continue;
                }

                LOGGER.debug(file.getAbsolutePath());
                KAFDocument document = KAFDocument.createFromFile(file);

                for (Coref coref : document.getCorefs()) {
                    if (coref.getType() == null) {
                        continue;
                    }
                    if (!coref.getType().equals("event-gold")) {
                        continue;
                    }

                    Integer cluster = Integer.parseInt(coref.getCluster());
                    String idCluster = String.valueOf(1000 * folder + cluster);

                    for (Span<Term> termSpan : coref.getSpans()) {
                        Term term = termSpan.getTargets().get(0);
                        String lemma = term.getLemma();

                        boolean add = false;
                        if (allLemmas != null && allLemmas.containsKey(lemma)) {
                            add = true;
                        }
                        if (lemmas == null || lemmas.containsKey(lemma)) {
                            add = true;
                        }

                        if (add) {
                            String text = folder + "_" + fileNum + "_" + term.getOffset();
                            goldTmpClusters.put(idCluster, text);
                            goldClusters.put(text, idCluster);
                            okEvents.add(text);
                        }
                    }
                }

                goldWriter.append(String.format("#begin document %d_%s", folder, fileNum)).append("\n");
                baselineWriter.append(String.format("#begin document %d_%s", folder, fileNum)).append("\n");

                Integer numSentences = document.getNumSentences();
                for (int i = 1; i <= numSentences; i++) {

                    boolean useThis = false;
                    StringBuilder goldBuilder = new StringBuilder();
                    StringBuilder baselineBuilder = new StringBuilder();

                    List<Term> sentenceTerms = document.getSentenceTerms(i);
                    int n = 0;
                    for (Term token : sentenceTerms) {
                        String id = String.format("%d_%s_%d", folder, fileNum, token.getOffset());
                        String last;
                        n++;

                        last = "_";
                        if (goldClusters.containsKey(id)) {
                            last = String.format("(%s)", goldClusters.get(id));
                            useThis = true;
                        }
                        printToken(goldBuilder, token, n, last);

                        last = "_";
                        String lemma = token.getLemma();
                        if (lemmas != null) {
                            if (goldClusters.containsKey(id) && lemmas.containsKey(lemma)) {
                                last = String.format("(%d)", lemmas.get(lemma));
                            }
                        }
                        if (allLemmas != null) {
                            if (goldClusters.containsKey(id) && allLemmas.containsKey(lemma)) {
                                last = String.format("(%d)", allLemmas.get(lemma));
                            }
                        }
                        if (!last.equals("_")) {
                            theBaseline.put(id, last);
                        }
                        printToken(baselineBuilder, token, n, last);
                    }

                    goldBuilder.append("\n");
                    baselineBuilder.append("\n");

                    if (useThis) {
                        goldWriter.append(goldBuilder.toString());
                        baselineWriter.append(baselineBuilder.toString());
                    }
                }
//                break;
            }

            goldWriter.close();
            baselineWriter.close();

//            Set<Set> goldClusters = new HashSet<>();
//            for (String key : goldTmpClusters.keySet()) {
//                Set<String> cluster = goldTmpClusters.get(key);
//                if (cluster.size() > 1 || !removeAloneClusters) {
//                    goldClusters.add(cluster);
//                }
//            }

//            LOGGER.info("Gold clusters: {}", goldClusters.size());

            in = new FileReader(inputCsv);
            records = CSVFormat.EXCEL.withHeader().parse(in);

            // Size must be always 4!
            int clusterID = 0;
            HashMap<String, Integer> clusterIndexes = new HashMap<>();
            HashMultimap<Integer, String> theClusters = HashMultimap.create();
            for (CSVRecord record : records) {
                Matcher matcher;

                String id1 = null;
                String id2 = null;
                matcher = tokenPattern.matcher(record.get(1));
                if (matcher.find()) {
                    id1 = matcher.group(1) + "_" + matcher.group(2) + "_" + matcher.group(3);
                }
                matcher = tokenPattern.matcher(record.get(3));
                if (matcher.find()) {
                    id2 = matcher.group(1) + "_" + matcher.group(2) + "_" + matcher.group(3);
                }

//                System.out.println(id1);
//                System.out.println(id2);

                Integer index1 = clusterIndexes.get(id1);
                Integer index2 = clusterIndexes.get(id2);

//                System.out.println(index1);
//                System.out.println(index2);

                if (index1 == null && index2 == null) {
                    clusterID++;
                    if (!checkGold || okEvents.contains(id2)) {
                        if (id2 != null) {
                            theClusters.put(clusterID, id2);
                            clusterIndexes.put(id2, clusterID);
                        }
                    }
                    if (!checkGold || okEvents.contains(id1)) {
                        if (id1 != null) {
                            theClusters.put(clusterID, id1);
                            clusterIndexes.put(id1, clusterID);
                        }
                    }
                }
                if (index1 == null && index2 != null) {
                    if (!checkGold || okEvents.contains(id1)) {
                        if (id1 != null) {
                            theClusters.put(index2, id1);
                            clusterIndexes.put(id1, index2);
                        }
                    }
                }
                if (index2 == null && index1 != null) {
                    if (!checkGold || okEvents.contains(id2)) {
                        if (id2 != null) {
                            theClusters.put(index1, id2);
                            clusterIndexes.put(id2, index1);
                        }
                    }
                }
                if (index2 != null && index1 != null) {
                    if (!index1.equals(index2)) {
                        if (id2 != null) {
                            clusterIndexes.put(id2, index1);
                            theClusters.putAll(index1, theClusters.get(index2));
                            theClusters.removeAll(index2);
                        }
                    }
                }
            }

//            System.out.println(theClusters);
//            System.out.println(theBaseline);

            int otherClusterID = 100000;
            for (final File file : Files.fileTreeTraverser().preOrderTraversal(inputNaf)) {
                if (!file.isFile()) {
                    continue;
                }
                if (file.getName().startsWith(".")) {
                    continue;
                }

//                String path = file.getParentFile().toString();
                String relativeFilePath = file.getAbsolutePath()
                        .substring(inputNaf.getAbsolutePath().length());

                Matcher matcher = fileNamePattern.matcher(relativeFilePath);
                Integer folder = null;
                String fileNum = null;
                if (matcher.find()) {
                    folder = Integer.parseInt(matcher.group(1));
                    fileNum = matcher.group(2);

                } else {
                    LOGGER.error("Error in file name: {}", relativeFilePath);
                    System.exit(1);
                }
//                Integer folder = Integer.parseInt(path.substring(path.lastIndexOf("/")).substring(1));
//                Integer fileNum = Integer.parseInt(file.getName().substring(0, file.getName().length() - 4));

                LOGGER.debug(file.getAbsolutePath());
                KAFDocument document = KAFDocument.createFromFile(file);

                if (FOLDER != null && !folder.equals(FOLDER)) {
                    continue;
                }

                writer.append(String.format("#begin document %d_%s", folder, fileNum)).append("\n");
                Integer numSentences = document.getNumSentences();
                for (int i = 1; i <= numSentences; i++) {

                    boolean useThis = false;
                    StringBuilder outBuilder = new StringBuilder();

                    List<Term> sentenceTerms = document.getSentenceTerms(i);
                    int n = 0;
                    for (Term token : sentenceTerms) {
                        String id = String.format("%d_%s_%d", folder, fileNum, token.getOffset());
                        if (okEvents.contains(id)) {
                            useThis = true;
                        }
                        String last = theBaseline.getOrDefault(id, "_");
                        if (clusterIndexes.containsKey(id)) {
                            last = String.format("(%d)", clusterIndexes.get(id) + 1000000);
                        }
                        if (last.equals("_")) {
                            if (okEvents.contains(id) && addSingleClusters) {
                                last = String.format("(%d)", ++otherClusterID);
                            }
                        }
                        printToken(outBuilder, token, ++n, last);
                    }

                    outBuilder.append("\n");

                    if (useThis) {
                        writer.append(outBuilder.toString());
                    }
                }

            }
            writer.close();

        } catch (Exception e) {
            CommandLine.fail(e);

        }
    }

}

    HashMap<String, Integer> sentenceTokens = new HashMap<String, Integer>();
    HashMap<String, Integer> stemmedTokens = new HashMap<String, Integer>();

    FuzzyMembership eT = new FuzzyMembership(1.0, 1.0, -1.0, -1.0);
    String[] tokens = text.split(" ");
    for(int i = 0; i < tokens.length; i++) {
      if(tokens[i].compareTo("") != 0) {
        String lexToken = this.wnlex.getWordLexicalizationByType(tokens[i].toLowerCase(), "MIX");
        //System.out.print(" " + lexToken + " ");
        if(lexToken != null) {
          tokens[i] = lexToken;
        }
        sentenceTokens.put(tokens[i], new Integer(i));

        porterStemmer stemmer = new porterStemmer();
        stemmer.setCurrent(tokens[i].toLowerCase());
        String stemLink = tokens[i].toLowerCase();
        if(stemmer.stem()) {
          stemLink = stemmer.getCurrent();
          //System.out.print(stemLink + " ");
        }
        stemmedTokens.put(stemLink, new Integer(i));
      }
    }
    Iterator<String> it = this.labels.keySet().iterator();
    while(it.hasNext()) {
      String currentConcept = it.next();
      String[] cts = currentConcept.split("_");
      int higherIdx = 0;
      int lowerIdx = tokens.length;
      int foundCT = 0;
      int flagNegation = 1;
      for(String ct: cts) {
        
        /*
        if(ct.compareTo("regret") == 0) {
          int A = 1;
        }
        */

        Integer tempIdx = sentenceTokens.get(ct);
        if(tempIdx == null) {
          tempIdx = stemmedTokens.get(ct);
        }
        if(tempIdx != null) {
          if(tempIdx < lowerIdx) lowerIdx = tempIdx;
          if(tempIdx > higherIdx) higherIdx = tempIdx;
          foundCT++;
        }
      }
      Integer notToken = sentenceTokens.get("not");
      if(notToken == null) {
        //notToken = sentenceTokens.get("no");
      }

      if(notToken != null &&
        (
         (notToken >= (lowerIdx - 2)) ||
         (
          (notToken > lowerIdx) && (notToken < higherIdx)
         )
        )
        ) {
        flagNegation = -1;
      }
      /*
      if(notToken != null && notToken == lowerIdx - 1) {
        flagNegation = -1;
      }
      */
      if(higherIdx >= 0 && foundCT == cts.length && (higherIdx - lowerIdx) < (cts.length + 2)) {

        Long feature = this.labels.get(currentConcept);
        //Long feature = labels.get(stemLink);
        
        /*
        double ratioFactor = 1.0 / (sentenceTokens.size() - lowerIdx);
        if(ratioFactor == Double.NaN || ratioFactor == 0.0) {
          ratioFactor = 1.0;
        }
        */
        double ratioFactor = 1.0;

        FuzzyMembership fm = this.polarities.get(feature);
        double a = 0.0;
        try {
          a = fm.getA() * ratioFactor * flagNegation;
        } catch (Exception e) {
          System.out.println("Error on getting fuzzy shape: " + currentConcept);
          //System.exit(0);
          return -2.0;
        }

        double b = fm.getB() * ratioFactor * flagNegation;
        double c = fm.getC() * ratioFactor * flagNegation;
        double d = fm.getD() * ratioFactor * flagNegation;

        if(flagNegation == -1) {
          double t = a;
          a = d;
          d = t;

          t = b;
          b = c;
          c = t;
        }

        double eA = eT.getA();
        double eB = eT.getB();
        double eC = eT.getC();
        double eD = eT.getD();

        if(a < eA) eA = a;
        if(b < eB) eB = b;
        if(c > eC) eC = c;
        if(d > eD) eD = d;

        eT.setA(eA);
        eT.setB(eB);
        eT.setC(eC);
        eT.setD(eD);

        fuzzyShapeFound += 1.0;
        tempPolarity += fm.getCentroidXAxis();
      }
    }

    if(eT.getA() != 1.0) {
      //textPolarity = eT.getCentroid();
      textPolarity = eT.getCentroidXAxis();
      if(Double.isNaN(textPolarity)) {
        return -2.0;
      }
      //textPolarity = tempPolarity / fuzzyShapeFound;
    }

    return textPolarity;
  }

    }

    private void addArguments(final KAFDocument document, final int sentence,
            final Opinion[] opinions) {

        // Index holder and target spans by expression head, keeping track of all exp. heads
        final Set<Term> expressionHeads = Sets.newHashSet();
        final Multimap<Term, Span<Term>> holderSpans = HashMultimap.create();
        final Multimap<Term, Span<Term>> targetSpans = HashMultimap.create();
        for (final Opinion opinion : opinions) {
            final Set<Term> heads = Opinions.heads(document,
                    NAFUtils.normalizeSpan(document, opinion.getExpressionSpan()),
                    Component.EXPRESSION);
            if (!heads.isEmpty()) {
                final Term head = Ordering.from(Term.OFFSET_COMPARATOR).max(heads);
                expressionHeads.add(head);
                final Span<Term> holderSpan = opinion.getHolderSpan();
                final Span<Term> targetSpan = opinion.getTargetSpan();
                if (holderSpan != null) {
                    holderSpans.putAll(head, NAFUtils.splitSpan(document, holderSpan, //
                            Opinions.heads(document, holderSpan, Component.HOLDER)));
                }
                if (targetSpan != null) {
                    targetSpans.putAll(head, NAFUtils.splitSpan(document, targetSpan, //
                            Opinions.heads(document, targetSpan, Component.TARGET)));
                }
            }
        }

        // Add training samples for holder and target extraction, separately (if enabled)
        for (final Term expressionHead : expressionHeads) {
            if (components().contains(Component.HOLDER)) {
                addArguments(document, sentence, expressionHead, holderSpans.get(expressionHead),
                        this.holderLinkTrainer, this.holderSpanTrainer);
            }
            if (components().contains(Component.TARGET)) {
                addArguments(document, sentence, expressionHead, targetSpans.get(expressionHead),
                        this.targetLinkTrainer, this.targetSpanTrainer);
            }
        }
    }

    private void addArguments(final KAFDocument document, final int sentence,
            final Term expressionHead, final Iterable<Span<Term>> argSpans,
            final LinkLabeller.Trainer linkTrainer, final SpanLabeller.Trainer spanTrainer) {

        // Extract heads and spans of the arguments (only where defined)
        final List<Term> heads = Lists.newArrayList();
        final List<Span<Term>> spans = Lists.newArrayList();
        for (final Span<Term> span : argSpans) {
            final Term head = NAFUtils.extractHead(document, span);
            if (head != null) {
                heads.add(head);
                spans.add(span);
            }
        }

        // Add a sample for node labelling
        linkTrainer.add(document, expressionHead, heads);

        // Add samples for span labelling (one for each argument)
        for (int i = 0; i < heads.size(); ++i) {
            final List<Term> excludedTerms = Lists.newArrayList(heads);
            excludedTerms.remove(heads.get(i));
            spanTrainer.add(document, heads.get(i), excludedTerms, spans.get(i));
        }
    }

}

                    .withHeader("Extract CR documents from TREC dataset and save them in NAF format")
                    .withOption("i", "input", "Input folder", "FOLDER", CommandLine.Type.DIRECTORY_EXISTING, true,
                            false, true)
                    .withOption("o", "output", "Output folder", "FOLDER", CommandLine.Type.DIRECTORY, true, false, true)
                    .withOption("u", "url-template", "URL template (with %d for the ID)", "URL",
                            CommandLine.Type.STRING, true, false, false)
                    .withLogger(LoggerFactory.getLogger("eu.fbk")) //
                    .parse(args);

            File inputDir = cmd.getOptionValue("input", File.class);

            String urlTemplate = DEFAULT_URL;
            if (cmd.hasOption("url-template")) {
                urlTemplate = cmd.getOptionValue("url-template", String.class);
            }

            File outputDir = cmd.getOptionValue("output", File.class);
            if (!outputDir.exists()) {
                outputDir.mkdirs();
            }

            for (final File file : Files.fileTreeTraverser().preOrderTraversal(inputDir)) {
                if (!file.isFile()) {
                    continue;
                }
                if (file.getName().startsWith(".")) {
                    continue;
                }

                String outputTemplate = outputDir.getAbsolutePath() + File.separator + file.getName();
                File newFolder = new File(outputTemplate);
                newFolder.mkdirs();

                outputTemplate += File.separator + "NAF";
                saveFile(file, outputTemplate, urlTemplate);
            }
        } catch (Exception e) {
            CommandLine.fail(e);
        }
    }

    private static void saveFile(File inputFile, String outputFilePattern, String urlTemplate)
            throws IOException, SAXException, ParserConfigurationException {

        LOGGER.info("Input file: {}", inputFile);

        StringBuffer stringBuffer = new StringBuffer();
        stringBuffer.append("<ROOT>\n");
        stringBuffer.append(Files.toString(inputFile, Charsets.UTF_8));
        stringBuffer.append("\n</ROOT>\n");

        InputStream is = new ByteArrayInputStream(stringBuffer.toString().getBytes());
        DocumentBuilderFactory dbFactory = DocumentBuilderFactory.newInstance();
        DocumentBuilder dBuilder = dbFactory.newDocumentBuilder();
        Document doc = dBuilder.parse(is);

        doc.getDocumentElement().normalize();

        int i = 0;
        for (Element element : JOOX.$(doc).find("DOC")) {
            Element docnoElement = JOOX.$(element).find("DOCNO").get(0);
            Element dateElement = JOOX.$(element).find("DATE").get(0);
            Element headlineElement = JOOX.$(element).find("TTL").get(0);

        }

        public List<Term> getTerms() {
            return this.span.getTargets();
        }

        public void addTerm(final Term term) {
            this.span.addTarget(term);
        }

        public void addTerm(final Term term, final boolean isHead) {
            this.span.addTarget(term, isHead);
        }

        public Span<Term> getSpan() {
            return this.span;
        }

        public void setSpan(final Span<Term> span) {
            this.span = span;
        }

        public ExternalRef getExternalRef(final String resource) {
            for (final ExternalRef ref : this.externalReferences) {
                if (ref.getResource().equalsIgnoreCase(resource)) {
                    return ref;
                }
            }
            return null;
        }

        public List<ExternalRef> getExternalRefs() {
            return this.externalReferences;
        }

        public void addExternalRef(final ExternalRef externalRef) {
            this.externalReferences.add(externalRef);
        }

        public void addExternalRefs(final List<ExternalRef> externalRefs) {
            this.externalReferences.addAll(externalRefs);
        }

        @Override
        public boolean equals(final Object object) {
            if (object == this) {
                return true;
            }
            if (!(object instanceof OpinionTarget)) {

    }

    public List<ExternalRef> getExternalRefs() {
	return externalReferences;
    }

    public void addExternalRef(ExternalRef externalRef) {
	externalReferences.add(externalRef);
    }

    public void addExternalRefs(List<ExternalRef> externalRefs) {
	externalReferences.addAll(externalRefs);
    }

    public String getSpanStr(Span<Term> span) {
	String str = "";
	for (Term term : span.getTargets()) {
	    if (!str.isEmpty()) {
		str += " ";
	    }
	    str += term.getStr();
	}
	return str;
    }

    public String getStr() {
	return getSpanStr(this.getSpans().get(0));
    }

    /** Deprecated */
    public List<List<Term>> getReferences() {
	List<List<Term>> list = new ArrayList<List<Term>>();
	for (Span<Term> span : this.references) {
	    list.add(span.getTargets());
	}
	return list;
    }

    /** Deprecated */
    public void addReference(List<Term> span) {
	this.references.add(KAFDocument.<Term>list2Span(span));
    }
}

            baselineWriter.close();

//            Set<Set> goldClusters = new HashSet<>();
//            for (String key : goldTmpClusters.keySet()) {
//                Set<String> cluster = goldTmpClusters.get(key);
//                if (cluster.size() > 1 || !removeAloneClusters) {
//                    goldClusters.add(cluster);
//                }
//            }

//            LOGGER.info("Gold clusters: {}", goldClusters.size());

            in = new FileReader(inputCsv);
            records = CSVFormat.EXCEL.withHeader().parse(in);

            // Size must be always 4!
            int clusterID = 0;
            HashMap<String, Integer> clusterIndexes = new HashMap<>();
            HashMultimap<Integer, String> tmpClusters = HashMultimap.create();
            for (CSVRecord record : records) {
                Matcher matcher;

                String id1 = null;
                String id2 = null;
                matcher = tokenPattern.matcher(record.get(1));
                if (matcher.find()) {
                    id1 = matcher.group(1) + "_" + matcher.group(2) + "_" + matcher.group(3);
                }
                matcher = tokenPattern.matcher(record.get(3));
                if (matcher.find()) {
                    id2 = matcher.group(1) + "_" + matcher.group(2) + "_" + matcher.group(3);
                }

                Integer index1 = clusterIndexes.get(id1);
                Integer index2 = clusterIndexes.get(id2);

                if (index1 == null && index2 == null) {
                    clusterID++;
                    if (!checkGold || okEvents.contains(id2)) {

    double deadzone = this.deadzone;
    
    int judged = 0;
    double precision = 0.0;
    double recall = 0.0;
    
    for(DatasetInstance di: instances) {
      ArrayList<String> features = di.getFeatures();
      int testPolarity = di.getPolarity();
      
      double inferredPolarity = 0.0;
      double a = 0.0;
      double b = 0.0;
      double c = 0.0;
      double d = 0.0;
      int mappedFeatures = 0;
      for(String currentFeature: features) {
        //Long featureId = labels.get(currentFeature);
        ArrayList<Long> featureIds = this.graph.getFeatureIds(currentFeature);
        if(featureIds != null) {
          for(Long featureId: featureIds) {
            mappedFeatures++;
            FuzzyMembership fm = this.polarities.get(featureId);
            if(fm != null) {
              inferredPolarity += fm.getCentroid();
              a += fm.getA();
              b += fm.getB();
              c += fm.getC();
              d += fm.getD();
            }
          }
        }
      }
      a /= (double) mappedFeatures;
      b /= (double) mappedFeatures;
      c /= (double) mappedFeatures;
      d /= (double) mappedFeatures;
      //inferredPolarity /= (double) mappedFeatures;
      inferredPolarity = (b + c) / 2.0;

        }

        private URI hash(final Resource subject, final URI predicate, final Value object) {
            final List<String> list = Lists.newArrayList();
            for (final Value value : new Value[] { subject, predicate, object }) {
                if (value instanceof URI) {
                    list.add("\u0001");
                    list.add(value.stringValue());
                } else if (value instanceof BNode) {
                    list.add("\u0002");
                    list.add(((BNode) value).getID());
                } else if (value instanceof Literal) {
                    final Literal l = (Literal) value;
                    list.add("\u0003");
                    list.add(l.getLabel());
                    if (l.getDatatype() != null) {
                        list.add(l.getDatatype().stringValue());
                    } else if (l.getLanguage() != null) {
                        list.add(l.getLanguage());
                    }
                }
            }
            final String id = Hash.murmur3(list.toArray(new String[list.size()])).toString();

@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "", propOrder = {
    "commentary",
    "sense",
    "wordmeta"
})
@XmlRootElement(name = "inventory")
public class Inventory {

    @XmlAttribute(name = "lemma", required = true)
    @XmlJavaTypeAdapter(NormalizedStringAdapter.class)
    protected String lemma;
    protected String commentary;
    @XmlElement(required = true)
    protected List<Sense> sense;
    @XmlElement(name = "WORD_META", required = true)
    protected WORDMETA wordmeta;

    /**
     * Recupera il valore della proprietà lemma.
     * 
     * @return
     *     possible object is
     *     {@link String }
     *     
     */
    public String getLemma() {
        return lemma;
    }

    /**
     * Imposta il valore della proprietà lemma.
     * 
     * @param value
     *     allowed object is
     *     {@link String }
     *     
     */
    public void setLemma(String value) {
        this.lemma = value;
    }

    /**
     * Recupera il valore della proprietà commentary.
     * 
     * @return
     *     possible object is
     *     {@link String }
     *     
     */
    public String getCommentary() {
        return commentary;
    }

    /**
     * Imposta il valore della proprietà commentary.
     * 
     * @param value
     *     allowed object is
     *     {@link String }
     *     
     */
    public void setCommentary(String value) {
        this.commentary = value;
    }

    /**
     * Gets the value of the sense property.
     * 
     * <p>
     * This accessor method returns a reference to the live list,
     * not a snapshot. Therefore any modification you make to the
     * returned list will be present inside the JAXB object.
     * This is why there is not a <CODE>set</CODE> method for the sense property.
     * 
     * <p>
     * For example, to add a new item, do as follows:
     * <pre>
     *    getSense().add(newItem);
     * </pre>
     * 
     * 
     * <p>
     * Objects of the following type(s) are allowed in the list
     * {@link Sense }
     * 
     * 
     */
    public List<Sense> getSense() {
        if (sense == null) {
            sense = new ArrayList<Sense>();
        }
        return this.sense;
    }

    /**
     * Recupera il valore della proprietà wordmeta.
     * 
     * @return
     *     possible object is
     *     {@link WORDMETA }
     *     
     */
    public WORDMETA getWORDMETA() {
        return wordmeta;
    }

    /**
     * Imposta il valore della proprietà wordmeta.
     * 
     * @param value
     *     allowed object is
     *     {@link WORDMETA }
     *     
     */
    public void setWORDMETA(WORDMETA value) {
        this.wordmeta = value;
    }

}

            HashMultimap<Integer, String> theClusters = HashMultimap.create();
            for (CSVRecord record : records) {
                Matcher matcher;

                String id1 = null;
                String id2 = null;
                matcher = tokenPattern.matcher(record.get(1));
                if (matcher.find()) {
                    id1 = matcher.group(1) + "_" + matcher.group(2) + "_" + matcher.group(3);
                }
                matcher = tokenPattern.matcher(record.get(3));
                if (matcher.find()) {
                    id2 = matcher.group(1) + "_" + matcher.group(2) + "_" + matcher.group(3);
                }

//                System.out.println(id1);
//                System.out.println(id2);

                Integer index1 = clusterIndexes.get(id1);
                Integer index2 = clusterIndexes.get(id2);

//                System.out.println(index1);
//                System.out.println(index2);

                if (index1 == null && index2 == null) {
                    clusterID++;
                    if (!checkGold || okEvents.contains(id2)) {
                        if (id2 != null) {

        this.jointSpan = Boolean.parseBoolean(properties.getProperty("joint", "false"));
        this.holderLinkTrainer = hasHolder ? LinkLabeller.train("NN", "PRP", "JJP", "DTP", "WP")
                : null;
        this.targetLinkTrainer = hasTarget ? LinkLabeller.train("NN", "PRP", "JJP", "DTP", "WP",
                "VB") : null;
        if (this.jointSpan) {
            final SpanLabeller.Trainer t = hasHolder || hasTarget ? SpanLabeller.train() : null;
            this.holderSpanTrainer = t;
            this.targetSpanTrainer = t;
        } else {
            this.holderSpanTrainer = hasHolder ? SpanLabeller.train() : null;
            this.targetSpanTrainer = hasTarget ? SpanLabeller.train() : null;
        }
        this.filter = NAFFilter.builder(false).withTermSenseCompletion(true)
                .withEntityAddition(true).withEntityRemoveOverlaps(true)
                .withEntitySpanFixing(true).withSRLPredicateAddition(true)
                .withSRLRemoveWrongRefs(true).withSRLSelfArgFixing(true).build();
    }

    @Override
    protected void doFilter(final KAFDocument document) {

            HashMultimap<Integer, String> theClusters = HashMultimap.create();
            for (CSVRecord record : records) {
                Matcher matcher;

                String id1 = null;
                String id2 = null;
                matcher = tokenPattern.matcher(record.get(1));
                if (matcher.find()) {
                    id1 = matcher.group(1) + "_" + matcher.group(2) + "_" + matcher.group(3);
                }
                matcher = tokenPattern.matcher(record.get(3));
                if (matcher.find()) {
                    id2 = matcher.group(1) + "_" + matcher.group(2) + "_" + matcher.group(3);
                }

//                System.out.println(id1);
//                System.out.println(id2);

                Integer index1 = clusterIndexes.get(id1);
                Integer index2 = clusterIndexes.get(id2);

//                System.out.println(index1);
//                System.out.println(index2);

                if (index1 == null && index2 == null) {
                    clusterID++;
                    if (!checkGold || okEvents.contains(id2)) {

		try {

			HashMap<String, Object> demoProperties = new HashMap<>();
			demoProperties.put("renderer.template.title", "PIKES demo");
			if (backLink) {
				demoProperties.put("renderer.template.backlink", "javascript:history.back();");
			}
			else {
				demoProperties.put("renderer.template.backlink", pipeline.getDefaultConfig().getProperty("back_alt_link"));
				demoProperties.put("renderer.template.backlabel", pipeline.getDefaultConfig().getProperty("back_alt_text"));
			}

			boolean fusion = request.getParameter("rdf_fusion") != null;
			boolean normalization = request.getParameter("rdf_compaction") != null;

			demoProperties.put("generator.fusion", fusion);
			demoProperties.put("generator.normalization", normalization);

			NAFFilter filter = NAFFilter.builder().withProperties(pipeline.getDefaultConfig(), "filter").build();
			RDFGenerator generator = RDFGenerator.builder().withProperties(demoProperties, "generator").build();

	for (Span<Term> span : entity.getSpans()) {
	    /* Copy span */
	    List<Term> targets = span.getTargets();
	    List<Term> copiedTargets = new ArrayList<Term>();
	    for (Term term : targets) {
		Term copiedTerm = terms.get(term.getId());
		if (copiedTerm == null) {
		    throw new IllegalStateException("Term not found when copying " + id);
		}
		copiedTargets.add(copiedTerm);
	    }
	    if (span.hasHead()) {
		Term copiedHead = terms.get(span.getHead().getId());
		this.references.add(new Span<Term>(copiedTargets, copiedHead));
	    }
	    else {
		this.references.add(new Span<Term>(copiedTargets));
	    }
	}
	/* Copy external references */
	this.externalReferences = new ArrayList<ExternalRef>();
	for (ExternalRef externalRef : entity.getExternalRefs()) {

	private <T> ArrayList<T> tsort(ListMap<T, T> depGraph) {

		HashSet<T> starts = new HashSet<T>();
		for (T k : depGraph.keySet()) {
			starts.add(k);
		}

		for (T k : depGraph.keySet()) {
			starts.removeAll(depGraph.get(k));
		}

		if (starts.size() == 0) {
			throw new RuntimeException("cyclic or empty graph!");
		}

		LinkedList<T> q = new LinkedList(starts);
		ArrayList<T> out = new ArrayList();

		while (!q.isEmpty()) {
			T t = q.removeFirst();
			out.add(t);
			ArrayList<T> sl = depGraph.get(t);
			if (sl != null) {

	this.sid = id;
    }

    public boolean hasType() {
	return type != null;
    }

    public String getType() {
	return type;
    }

    public void setType(String type) {
	this.type = type;
    }

    public boolean hasLemma() {
	return lemma != null;
    }

    public String getLemma() {
	return lemma;
    }

    public void setLemma(String lemma) {
	this.lemma = lemma;
    }

    public boolean hasPos() {
	return pos != null;
    }

    public String getPos() {
	return pos;
    }

    public void setPos(String pos) {
	this.pos = pos;
    }

    public boolean hasMorphofeat() {
	return morphofeat != null;
    }

    public String getMorphofeat() {
	return morphofeat;
    }

    public void setMorphofeat(String morphofeat) {
	this.morphofeat = morphofeat;
    }

    public boolean hasCase() {
	return markcase != null;

@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "", propOrder = {
    "noteOrRoleset"
})
@XmlRootElement(name = "predicate")
public class Predicate {

    @XmlAttribute(name = "lemma", required = true)
    @XmlJavaTypeAdapter(NormalizedStringAdapter.class)
    protected String lemma;
    @XmlElements({
        @XmlElement(name = "note", type = Note.class),
        @XmlElement(name = "roleset", type = Roleset.class)
    })
    protected List<Object> noteOrRoleset;

    /**
     * Recupera il valore della proprietà lemma.
     * 
     * @return
     *     possible object is
     *     {@link String }
     *     
     */
    public String getLemma() {
        return lemma;
    }

    /**
     * Imposta il valore della proprietà lemma.
     * 
     * @param value
     *     allowed object is
     *     {@link String }
     *     
     */
    public void setLemma(String value) {
        this.lemma = value;
    }

    /**
     * Gets the value of the noteOrRoleset property.
     * 
     * <p>
     * This accessor method returns a reference to the live list,
     * not a snapshot. Therefore any modification you make to the
     * returned list will be present inside the JAXB object.
     * This is why there is not a <CODE>set</CODE> method for the noteOrRoleset property.
     * 
     * <p>
     * For example, to add a new item, do as follows:
     * <pre>
     *    getNoteOrRoleset().add(newItem);
     * </pre>
     * 
     * 
     * <p>
     * Objects of the following type(s) are allowed in the list
     * {@link Note }
     * {@link Roleset }
     * 
     * 
     */
    public List<Object> getNoteOrRoleset() {
        if (noteOrRoleset == null) {
            noteOrRoleset = new ArrayList<Object>();
        }
        return this.noteOrRoleset;
    }

}

    this.semanticConcepts = new ArrayList<String>();
    //String terms = this.lexString.replaceAll("\\./\\.", "");
    //String[] termsList = terms.split(" ");
    String[] termsList = this.lexString.split(" ");
    boolean compoundNounFlag = false;
    for(String currentTerm : termsList) {
      String[] atom = currentTerm.split("/");
      if(atom.length > 1) {
        Integer stopFlag = wnl.getStopwords().get(atom[0]);
        if(stopFlag != null) continue;
        if(atom[1].compareTo("NN") == 0 || atom[1].compareTo("NNP") == 0 || atom[1].compareTo("NNPS") == 0 ||
           atom[1].compareTo("NNS") == 0 || atom[1].compareTo("FW") == 0) {
          String newAspect;
          if(compoundNounFlag == true) {
            newAspect = this.semanticConcepts.get(this.semanticConcepts.size() - 1);

  }
  
  
  
  
  /**
   * Utility method that convert the blitzer review in the eswc2014 challenge format
   */
  public void convertReviewToESWCChallenge(String filename, String datasetName) {
    FileManager fm = new FileManager(filename, Mode.READ);
    //String content = fm.importFullTextContent();
    ArrayList<String> contents = fm.importSimpleTextContent();
    
    FileManager rdfOut = new FileManager("/home/drago/Documents/java_projects/research/nlp/multi_domain_fuzzy_sentiment_analysis/eswc2014_challenge_mdfsa_dragoni/task3/" + datasetName + ".validation.rdf.xml", Mode.WRITE);
    
    rdfOut.write("<?xml version=\"1.0\" encoding=\"UTF-8\"?>");
    rdfOut.write("<rdf:RDF xmlns:rdf=\"http://www.w3.org/1999/02/22-rdf-syntax-ns#\">");
    int reviewId = 1;
    //int startText = content.indexOf("<review_text");
    //int endText = content.indexOf("</review_text", startText + 10);
    //while (startText != -1) {
    for(String currentReview: contents) {
      /* Gets the review text */
      //String currentReview = content.substring(startText + 14, endText - 1).replaceAll("\n", "");
      currentReview = currentReview.replace("&", "&amp;");
      //currentReview = "I gave up to go to supermarkets yesterday.";
            
      /* Write the review in the RDF format */
      rdfOut.write("\t<rdf:Description rdf:about=\"http://sentic.net/challenge/sentence_" + reviewId + "\">");
      //rdfOut.write("\t\t<sentence xmlns=\"http://sentic.net/challenge/\" rdf:resource=\"http://sentic.net/challenge/sentence_" + reviewId + "\">");
      rdfOut.write("\t\t\t<text xmlns=\"http://sentic.net/challenge/\" rdf:datatype=\"http://www.w3.org/TR/rdf-text/\">");
      //rdfOut.write("\t\t\t<![CDATA[" + currentReview + "]]>");
      rdfOut.write("\t\t\t" + currentReview + "");
      rdfOut.write("\t\t\t</text>");
      //rdfOut.write("\t\t</sentence>");
      rdfOut.write("\t</rdf:Description>");
      
      
      /* Gets next text to analyze */
      //startText = content.indexOf("<review_text", endText + 10);
      //endText = content.indexOf("</review_text", startText + 10);
      //System.out.println(reviewId + " - " + startText + " - " + endText);
      reviewId++;
    }
    rdfOut.write("</rdf:RDF>");
    rdfOut.close();
    fm.close();
  }
  
  
}

@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "", propOrder = {
    "value"
})
@XmlRootElement(name = "arg")
public class Arg {

    @XmlAttribute(name = "n", required = true)
    @XmlJavaTypeAdapter(NormalizedStringAdapter.class)
    protected String n;
    @XmlAttribute(name = "f")
    @XmlJavaTypeAdapter(NormalizedStringAdapter.class)
    protected String f;
    @XmlValue
    protected String value;

    /**
     * Recupera il valore della proprietà n.
     * 
     * @return
     *     possible object is
     *     {@link String }
     *     
     */
    public String getN() {
        return n;
    }

    /**
     * Imposta il valore della proprietà n.
     * 
     * @param value
     *     allowed object is
     *     {@link String }
     *     
     */
    public void setN(String value) {
        this.n = value;
    }

    /**
     * Recupera il valore della proprietà f.
     * 
     * @return
     *     possible object is
     *     {@link String }
     *     
     */
    public String getF() {
        return f;
    }

    /**
     * Imposta il valore della proprietà f.
     * 
     * @param value
     *     allowed object is
     *     {@link String }
     *     
     */
    public void setF(String value) {
        this.f = value;
    }

    /**
     * Recupera il valore della proprietà value.
     * 
     * @return
     *     possible object is
     *     {@link String }
     *     
     */
    public String getvalue() {
        return value;
    }

    /**
     * Imposta il valore della proprietà value.
     * 
     * @param value
     *     allowed object is
     *     {@link String }
     *     
     */
    public void setvalue(String value) {
        this.value = value;
    }

}

@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "", propOrder = {
    "value"
})
@XmlRootElement(name = "wn")
public class Wn {

    @XmlAttribute(name = "version", required = true)
    @XmlJavaTypeAdapter(NormalizedStringAdapter.class)
    protected String version;
    @XmlAttribute(name = "lemma")
    @XmlJavaTypeAdapter(NormalizedStringAdapter.class)
    protected String lemma;
    @XmlValue
    protected String value;

    /**
     * Recupera il valore della proprietà version.
     * 
     * @return
     *     possible object is
     *     {@link String }
     *     
     */
    public String getVersion() {
        return version;
    }

    /**
     * Imposta il valore della proprietà version.
     * 
     * @param value
     *     allowed object is
     *     {@link String }
     *     
     */
    public void setVersion(String value) {
        this.version = value;
    }

    /**
     * Recupera il valore della proprietà lemma.
     * 
     * @return
     *     possible object is
     *     {@link String }
     *     
     */
    public String getLemma() {
        return lemma;
    }

    /**
     * Imposta il valore della proprietà lemma.
     * 
     * @param value
     *     allowed object is
     *     {@link String }
     *     
     */
    public void setLemma(String value) {
        this.lemma = value;
    }

    /**
     * Recupera il valore della proprietà value.
     * 
     * @return
     *     possible object is
     *     {@link String }
     *     
     */
    public String getvalue() {
        return value;
    }

    /**
     * Imposta il valore della proprietà value.
     * 
     * @param value
     *     allowed object is
     *     {@link String }
     *     
     */
    public void setvalue(String value) {
        this.value = value;
    }

}

        String line;
        while ((line = brCleanUp.readLine()) != null) {
            LOGGER.trace(line);
            String[] parts = line.split("\\s+");
            String context = parts[0];
            if (context.equals("ctx_02")) {
                break;
            }

            String tokenID = parts[1];
            HashMap<String, String> thisTerm = backupTerms.get(tokenID);
            if (thisTerm == null) {
                continue;
            }

            for (int i = 2; i < parts.length; i++) {
                String[] scores = parts[i].split("/");
                if (scores.length < 2) {
                    break;
                }
                String wn = scores[0];

                thisTerm.put("wordnet", wn);

                break;

            }
        }

    }

        }

        public Builder withProperties(final Map<?, ?> properties, @Nullable final String prefix) {
            final String p = prefix == null ? "" : prefix.endsWith(".") ? prefix : prefix + ".";
            for (final Map.Entry<?, ?> entry : properties.entrySet()) {
                if (entry.getKey() != null && entry.getValue() != null
                        && entry.getKey().toString().startsWith(p)) {
                    final String name = entry.getKey().toString().substring(p.length());
                    final String value = Strings.emptyToNull(entry.getValue().toString());
                    if ("template".equals(name)) {

        public Builder withProperties(final Map<?, ?> properties, @Nullable final String prefix) {
            final String p = prefix == null ? "" : prefix.endsWith(".") ? prefix : prefix + ".";
            for (final Map.Entry<?, ?> entry : properties.entrySet()) {
                if (entry.getKey() != null && entry.getValue() != null
                        && entry.getKey().toString().startsWith(p)) {
                    final String name = entry.getKey().toString().substring(p.length());
                    final String value = Strings.emptyToNull(entry.getValue().toString());
                    if ("fusion".equals(name)) {

            for (final File file : Files.fileTreeTraverser().preOrderTraversal(inputNaf)) {
                if (!file.isFile()) {
                    continue;
                }
                if (file.getName().startsWith(".")) {
                    continue;
                }

                String path = file.getParentFile().toString();
                Integer folder = Integer.parseInt(path.substring(path.lastIndexOf("/")).substring(1));
                Integer fileNum = Integer.parseInt(file.getName().substring(0, file.getName().length() - 4));

                LOGGER.debug(file.getAbsolutePath());
                KAFDocument document = KAFDocument.createFromFile(file);

            }
            final Classifier classifier = Classifier.train(grid, this.trainingSet,
                    ConfusionMatrix.labelComparator(PrecisionRecall.Measure.F1, 1, true), 100000);

            // Log parameters of the best classifier
            LOGGER.info("Best classifier parameters: {}", classifier.getParameters());

            // Perform cross-validation and emit some performance statistics, if enabled
            if (analyze && LOGGER.isInfoEnabled()) {
                final List<LabelledVector> trainingPredictions = classifier.predict(false,
                        this.trainingSet);
                final ConfusionMatrix matrix = LabelledVector.evaluate(this.trainingSet,
                        trainingPredictions, 2);
                LOGGER.info("Performances on training set:\n{}", matrix);
                final ConfusionMatrix crossMatrix = Classifier.crossValidate(
                        classifier.getParameters(), this.trainingSet, 5, -1);
                LOGGER.info("5-fold cross-validation performances:\n{}", crossMatrix);
            }

            // Build and return the created link labeller
            return new LinkLabeller(classifier, this.posPrefixes);

    public Path file(final Object key) {
        try {
            int index;
            if (key instanceof Number) {
                index = ((Number) key).intValue();
            } else if (key instanceof File) {
                index = Arrays.binarySearch(this.files, ((File) key).toPath());
            } else if (key instanceof Path) {
                index = Arrays.binarySearch(this.files, key);
            } else {
                index = Arrays.binarySearch(this.files, Paths.get(key.toString()));
            }
            if (index < 0 || index >= this.files.length) {
                throw new IllegalArgumentException("No file in this corpus for " + key);
            }

                emitMeta(docURI, DCTERMS.LANGUAGE,
                        ModelUtil.languageCodeToURI(this.document.getLang()));
            }

            // Emit an hash of the whitespace-normalized raw text, if available
            if (this.document.getRawText() != null) {
                final String rawText = this.document.getRawText();
                final StringBuilder builder = new StringBuilder();
                boolean addSpace = false;
                for (int i = 0; i < rawText.length(); ++i) {
                    final char c = rawText.charAt(i);
                    if (Character.isWhitespace(c)) {
                        addSpace = builder.length() > 0;
                    } else {
                        if (addSpace) {
                            builder.append(' ');
                            addSpace = false;
                        }
                        builder.append(c);
                    }
                }

              String key = new String(d[0] + "^^^" + d[2] + "^^^" + d[1]);
              t = domainModel.get(key);
              tI = domainIndependentModel.get(key);
              if(t == null) {
                t = new Tuple(1);
                t.setToken(key);
                t.setFrequency(1.0);
              } else {
                t.setFrequency(t.getFrequency() + 1.0);
              }
              if(tI == null) {
                tI = new Tuple(1);
                tI.setToken(key);
                tI.setFrequency(1.0);
              } else {
                tI.setFrequency(t.getFrequency() + 1.0);
              }
              domainModel.put(key, t);
              domainIndependentModel.put(key, tI);

            HashMap<String, String> goldClusters = new HashMap<>();
            Set<String> okEvents = new HashSet<>();

            for (final File file : Files.fileTreeTraverser().preOrderTraversal(inputNaf)) {
                if (!file.isFile()) {
                    continue;
                }
                if (file.getName().startsWith(".")) {
                    continue;
                }

                String path = file.getParentFile().toString();
                Integer folder = Integer.parseInt(path.substring(path.lastIndexOf("/")).substring(1));
                Integer fileNum = Integer.parseInt(file.getName().substring(0, file.getName().length() - 4));

            File outputFolder = cmd.getOptionValue("output", File.class);

            if (!outputFolder.exists()) {
                outputFolder.mkdirs();
            }

            DocumentBuilderFactory dbFactory = DocumentBuilderFactory.newInstance();
            DocumentBuilder dBuilder = dbFactory.newDocumentBuilder();

            // uncomment to get the manual mention spans
            //Pattern MY_PATTERN = Pattern.compile("\\\">[^<]*</MENTION>");

            String tags;

            int i = 0;
            for (final File file : Files.fileTreeTraverser().preOrderTraversal(inputFolder)) {
                if (!file.isFile()) {
                    continue;
                }
                if (file.getName().startsWith(".")) {
                    continue;
                }

                String path = file.getParentFile().toString();
                String folder = path.substring(path.lastIndexOf("/"));
                String local_name = folder + File.separator + file.getName();

                String naf = nafFolder + File.separator + folder + File.separator + file.getName()

              String key = new String(d[0] + "^^^" + d[2] + "^^^" + d[1]);
              t = domainModel.get(key);
              tI = domainIndependentModel.get(key);
              if(t == null) {
                t = new Tuple(1);
                t.setToken(key);
                t.setFrequency(1.0);
              } else {
                t.setFrequency(t.getFrequency() + 1.0);
              }
              if(tI == null) {
                tI = new Tuple(1);
                tI.setToken(key);
                tI.setFrequency(1.0);
              } else {
                tI.setFrequency(t.getFrequency() + 1.0);
              }
              domainModel.put(key, t);
              domainIndependentModel.put(key, tI);
              
              /* Key: governor-dependent */
              key = new String(d[1] + "^^^" + d[2]);

            HashSet<String> skipPatterns = new HashSet<>();
            if (skip != null) {
                BufferedReader reader = new BufferedReader(new FileReader(skip));
                String line;
                while ((line = reader.readLine()) != null) {
                    line = line.trim();
                    skipPatterns.add(line);
                }
                reader.close();
            }

            if (!input.exists()) {
                logger.error("Input folder does not exist");
                System.exit(1);
            }

            if (!output.exists()) {
                if (!output.mkdirs()) {
                    logger.error("Unable to create output folder");
                    System.exit(1);
                }
            }

    public static final Map<Object, String> DEFAULT_COLOR_MAP = ImmutableMap
            .<Object, String>builder() //
            .put("node", "#F0F0F0") //
            .put(NWR.PERSON, "#FFC8C8") //
            .put(NWR.ORGANIZATION, "#FFFF84") //
            .put(NWR.LOCATION, "#A9C5EB") //
            .put(KS.ATTRIBUTE, "#EEBBEE") //
            // .put(KS.MONEY, "#EEBBEE") //
            // .put(KS.FACILITY, "#FFC65B") //
            // .put(KS.PRODUCT, "#FFC65B") //
            // .put(KS.WORK_OF_ART, "#FFC65B") //
            .put(SUMO.PROCESS, "#CFE990") //
            .put(SUMO.RELATION, "#FFFFFF") //
            .put(OWLTIME.INTERVAL, "#B4D1B6") //
            .put(OWLTIME.DATE_TIME_INTERVAL, "#B4D1B6") //
            .put(OWLTIME.PROPER_INTERVAL, "#B4D1B6") //
            .put(NWR.MISC, "#D1BAA2") //
            // .put(KS.LAW, "#D1BAA2") //
            .build();

            final Model mentionModel = new LinkedHashModel();
            for (final Statement statement : model.filter(mentionID, null, null)) {
                final URI pred = statement.getPredicate();
                if (!NIF.BEGIN_INDEX.equals(pred) && !NIF.END_INDEX.equals(pred)
                        && !NIF.ANCHOR_OF.equals(pred) && !RDF.TYPE.equals(pred)
                        && !KS.MENTION_OF.equals(pred)) {
                    mentionModel.add(statement);
                }
            }
            if (!mentionModel.isEmpty()) {
                renderProperties(out, mentionModel, mentionID, false);
            }
            out.append("</td><td>");
            renderObject(out, model.filter(null, GAF.DENOTED_BY, mentionID).subjects(), model);

        StringBuffer stringBuffer = new StringBuffer();
        stringBuffer.append("<ROOT>\n");
        stringBuffer.append(Files.toString(inputFile, Charsets.UTF_8));
        stringBuffer.append("\n</ROOT>\n");

        InputStream is = new ByteArrayInputStream(stringBuffer.toString().getBytes());
        DocumentBuilderFactory dbFactory = DocumentBuilderFactory.newInstance();
        DocumentBuilder dBuilder = dbFactory.newDocumentBuilder();
        Document doc = dBuilder.parse(is);

        doc.getDocumentElement().normalize();

        int i = 0;
        for (Element element : JOOX.$(doc).find("DOC")) {
            Element docnoElement = JOOX.$(element).find("DOCNO").get(0);
            Element dateElement = JOOX.$(element).find("DATE").get(0);

                LOGGER.error("TEXT is null");
                continue;
            }

            String docno = "";
            if (docnoElement != null) {
                docno = docnoElement.getTextContent().trim();
            }

            String date = "";
            if (dateElement != null) {
                date = dateElement.getTextContent().trim();
            }

            String headline = "";
            if (headlineElement != null) {
                headline = headlineElement.getTextContent().trim();
            }

            if (docno.equals("")) {
                LOGGER.error("DOCNO is empty");
            }

            String url = String.format(urlTemplate, docno);

            headline = headline.replace('\n', ' ');
            headline = headline.replaceAll("\\s+", " ");

			}

			// Holder
			String sources = thisRecord.getValue("nested-source");
			addSources(sources, agentRecords, lastRecords, sentenceSpan, fields, documentURI, text);

			// Emit TSV string
			tsvWriter.append(getTsvString(documentURI, fields));

			// Print debug
			LOGGER.debug(fields.get("type").toString());
			LOGGER.debug(fields.toString());
			for (String expression : fields.get("expression")) {
				LOGGER.debug(expression);
				Span span = new Span(expression);
				LOGGER.debug(span.apply(text));
			}
			System.out.println();
		}

		// Expressive
		for (final Record thisRecord : annotations.getRecords("GATE_expressive-subjectivity")) {

              key = new String(d[1] + "^^^" + d[2]);
              t = domainModel.get(key);
              tI = domainIndependentModel.get(key);
              if(t == null) {
                t = new Tuple(1);
                t.setToken(key);
                t.setFrequency(1.0);
              } else {
                t.setFrequency(t.getFrequency() + 1.0);
              }
              if(tI == null) {
                tI = new Tuple(1);
                tI.setToken(key);
                tI.setFrequency(1.0);
              } else {
                tI.setFrequency(t.getFrequency() + 1.0);
              }
              domainModel.put(key, t);
              domainIndependentModel.put(key, tI);

        String line = brCleanUp.readLine();
    }

    private static void addTokenToContext(HashMap<String, String> term, char pos, int index, StringBuffer sb,
            HashMap<String, HashMap<String, String>> backupTerms) {
        String thisID = "w" + index;
        sb.append(term.get("lemma").toLowerCase().replace(' ', '-').replace('#', '.'));
        sb.append("#");
        sb.append(pos);
        sb.append("#");
        sb.append(thisID);
        sb.append("#1");
        sb.append(" ");
        backupTerms.put(thisID, term);
    }

            String docno = "";
            if (docnoElement != null) {
                docno = docnoElement.getTextContent().trim();
            }

            String date = "";
            if (dateElement != null) {
                date = dateElement.getTextContent().trim();
            }

            String headline = "";
            if (headlineElement != null) {
                headline = headlineElement.getTextContent().trim();
            }

            if (docno.equals("")) {
                LOGGER.error("DOCNO is empty");
            }

            String url = String.format(urlTemplate, docno);

            headline = headline.replace('\n', ' ');
            headline = headline.replaceAll("\\s+", " ");

                    String value = outputMappingsForRoles.get(outputMapping).get(key);

                    String[] parts = value.split("@");
                    if (parts.length < 2) {
                        LOGGER.error("This is impossible!");
                        break;
                    }
                    URI fbURI = FrameBase.propertyFor(parts[0], parts[1]);
                    if (fbURI == null) {
                        LOGGER.error("This should never happen!");
                        LOGGER.debug(key);
                        LOGGER.debug(value);
                        break;
                    }

                    writer.append(outputMapping.toString()).append('\t');
                    writer.append(key).append('\t');
                    writer.append(value).append('\t');

            return this;
        }

        public Builder withColorMap(@Nullable final Map<Object, String> colorMap) {
            this.colorMap = colorMap;
            return this;
        }

        public Builder withStyleMap(@Nullable final Map<Object, String> styleMap) {
            this.styleMap = styleMap;
            return this;
        }

        public Builder withTemplate(@Nullable final Object template) {
            this.template = template == null ? null : loadTemplate(template);
            return this;
        }

        public Builder withTemplateParameter(final String name, @Nullable final Object value) {
            this.templateParameters.put(name, value);
            return this;
        }

        public Renderer build() {
            return new Renderer(this);

@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "")
@XmlRootElement(name = "vnrole")
public class Vnrole {

    @XmlAttribute(name = "vncls", required = true)
    @XmlJavaTypeAdapter(NormalizedStringAdapter.class)
    protected String vncls;
    @XmlAttribute(name = "vntheta", required = true)
    @XmlJavaTypeAdapter(CollapsedStringAdapter.class)
    protected String vntheta;

    /**
     * Recupera il valore della proprietà vncls.
     * 
     * @return
     *     possible object is
     *     {@link String }
     *     
     */
    public String getVncls() {
        return vncls;
    }

    /**
     * Imposta il valore della proprietà vncls.
     * 
     * @param value
     *     allowed object is
     *     {@link String }
     *     
     */
    public void setVncls(String value) {
        this.vncls = value;
    }

    /**
     * Recupera il valore della proprietà vntheta.
     * 
     * @return
     *     possible object is
     *     {@link String }
     *     
     */
    public String getVntheta() {
        return vntheta;
    }

    /**
     * Imposta il valore della proprietà vntheta.
     * 
     * @param value
     *     allowed object is
     *     {@link String }
     *     
     */
    public void setVntheta(String value) {
        this.vntheta = value;
    }

}

            Set<String> okEvents = new HashSet<>();

            for (final File file : Files.fileTreeTraverser().preOrderTraversal(inputNaf)) {
                if (!file.isFile()) {
                    continue;
                }
                if (file.getName().startsWith(".")) {
                    continue;
                }

                String path = file.getParentFile().toString();
                Integer folder = Integer.parseInt(path.substring(path.lastIndexOf("/")).substring(1));
                Integer fileNum = Integer.parseInt(file.getName().substring(0, file.getName().length() - 4));

            for (final File file : Files.fileTreeTraverser().preOrderTraversal(inputNaf)) {
                if (!file.isFile()) {
                    continue;
                }
                if (file.getName().startsWith(".")) {
                    continue;
                }

                String path = file.getParentFile().toString();
                Integer folder = Integer.parseInt(path.substring(path.lastIndexOf("/")).substring(1));
                Integer fileNum = Integer.parseInt(file.getName().substring(0, file.getName().length() - 4));

      int polarity = di.getPolarity();
      
      for(String currentFeature: features) {
        
        ArrayList<Long> featureIds = this.graph.getFeatureIds(currentFeature);
        if(featureIds != null) {
          for(Long featureId: featureIds) {
            Double currentPolarity = this.startPolarities.get(featureId);
            if(currentPolarity == null) {
              currentPolarity = new Double(polarity);
              this.startPolarities.put(featureId, currentPolarity);
              this.currentPolarities.put(featureId, currentPolarity);
            } else {
              currentPolarity += polarity;
              this.startPolarities.put(featureId, currentPolarity);
              this.currentPolarities.put(featureId, currentPolarity);
            }

        stringBuffer.append(Files.toString(inputFile, Charsets.UTF_8));
        stringBuffer.append("\n</ROOT>\n");

        InputStream is = new ByteArrayInputStream(stringBuffer.toString().getBytes());
        DocumentBuilderFactory dbFactory = DocumentBuilderFactory.newInstance();
        DocumentBuilder dBuilder = dbFactory.newDocumentBuilder();
        Document doc = dBuilder.parse(is);

        doc.getDocumentElement().normalize();

        int i = 0;
        for (Element element : JOOX.$(doc).find("DOC")) {
            Element docnoElement = JOOX.$(element).find("DOCNO").get(0);
            Element dateElement = JOOX.$(element).find("DATE").get(0);

                                    "Every property must contain a 'span' element inside 'references'");
                        }
                        List<Span<Term>> references = new ArrayList<Span<Term>>();
                        for (Element spanElem : spanElems) {
                            Span<Term> span = kaf.newTermSpan();
                            List<Element> targetElems = spanElem.getChildren();
                            if (targetElems.size() < 1) {
                                throw new IllegalStateException(
                                        "Every span in a property must contain at least one target inside");
                            }
                            for (Element targetElem : targetElems) {
                                String targetTermId = getAttribute("id", targetElem);
                                Term targetTerm = termIndex.get(targetTermId);
                                if (targetTerm == null) {
                                    throw new KAFNotValidException(
                                            "Term " + targetTermId + " not found when loading property " + pid);

@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "")
@XmlRootElement(name = "WORD_META")
public class WORDMETA {

    @XmlAttribute(name = "authors", required = true)
    @XmlJavaTypeAdapter(NormalizedStringAdapter.class)
    protected String authors;
    @XmlAttribute(name = "sample_score")
    @XmlJavaTypeAdapter(NormalizedStringAdapter.class)
    protected String sampleScore;

    /**
     * Recupera il valore della proprietà authors.
     * 
     * @return
     *     possible object is
     *     {@link String }
     *     
     */
    public String getAuthors() {
        return authors;
    }

    /**
     * Imposta il valore della proprietà authors.
     * 
     * @param value
     *     allowed object is
     *     {@link String }
     *     
     */
    public void setAuthors(String value) {
        this.authors = value;
    }

    /**
     * Recupera il valore della proprietà sampleScore.
     * 
     * @return
     *     possible object is
     *     {@link String }
     *     
     */
    public String getSampleScore() {
        return sampleScore;
    }

    /**
     * Imposta il valore della proprietà sampleScore.
     * 
     * @param value
     *     allowed object is
     *     {@link String }
     *     
     */
    public void setSampleScore(String value) {
        this.sampleScore = value;
    }

}

            while (true) {
                String filename = null;
                try {
                    filename = getNextFile(session);
                    if (filename == null) {
                        break;
                    }

                    File file = new File(filename);
                    if (!file.exists()) {
                        break;
                    }

                    File outputFile = getOutputFile(file, session);

                    // todo: use parameters
                    outputFile = new File(outputFile.getAbsolutePath() + ".gz");

                    logger.debug("Output file: " + outputFile);

                    logger.info("Loading file: " + filename);
                    BufferedReader reader = new BufferedReader(new FileReader(filename));
                    String whole = IOUtils.toString(reader);
                    reader.close();

        writer.append("_").append("\t");
        writer.append("_").append("\t");
        writer.append("_").append("\t");
        writer.append("_").append("\t");
        writer.append("_").append("\t");
        writer.append("_").append("\t");
        writer.append("_").append("\t");
        writer.append("_").append("\t");
        writer.append("_").append("\t");
        writer.append("_").append("\t");
        writer.append(last);

			}

			// Holder
			String sources = thisRecord.getValue("nested-source");
			addSources(sources, agentRecords, lastRecords, sentenceSpan, fields, documentURI, text);

			// Emit TSV string
			tsvWriter.append(getTsvString(documentURI, fields));

			// Print debug
			LOGGER.debug(fields.get("type").toString());
			LOGGER.debug(fields.toString());
			for (String expression : fields.get("expression")) {
				LOGGER.debug(expression);
				Span span = new Span(expression);
				LOGGER.debug(span.apply(text));
			}
			System.out.println();
		}

				SentiWordNet.init();
			}

			LOGGER.info("Parsing corpus");
			Corpus[] corpuses = new Corpus[2];
			if (trainList != null) {
				List<File> trainFiles = readList(trainList, mainFolder, "naf");
				List<File> testFiles = readList(testList, mainFolder, "naf");
				corpuses[0] = Corpus.create(false, trainFiles);
				corpuses[1] = Corpus.create(false, testFiles);
			}
			else {
				Corpus myCorpus = Corpus.create(false, mainFolder);
				corpuses = myCorpus.split(seed, split, 1.0f - split);
			}

                if (file.getName().startsWith(".")) {
                    continue;
                }

                String outputTemplate = outputDir.getAbsolutePath() + File.separator + file.getName();
                File newFolder = new File(outputTemplate);
                newFolder.mkdirs();

                outputTemplate += File.separator + "NAF";
                saveFile(file, outputTemplate, urlTemplate);
            }
        } catch (Exception e) {
            CommandLine.fail(e);
        }
    }

    private static void saveFile(File inputFile, String outputFilePattern, String urlTemplate)
            throws IOException, SAXException, ParserConfigurationException {

        LOGGER.info("Input file: {}", inputFile);

        StringBuffer stringBuffer = new StringBuffer();
        stringBuffer.append("<?xml version=\"1.0\"?>\n"

			boolean forceOpinion = cmd.hasOption("f");
			 
			final File inputPath = cmd.getOptionValue("i", File.class);
			if (!inputPath.exists()) {
				throw new IOException(String.format("Folder %s does not exist", inputPath.getAbsolutePath()));
			}

			File kafPath = new File(inputPath.getAbsolutePath() + File.separator + "kaf");
			if (!kafPath.exists()) {
				throw new IOException(String.format("Folder %s does not exist", kafPath.getAbsolutePath()));
			}
			File nafPath = new File(inputPath.getAbsolutePath() + File.separator + "naf-parsed");

					String lemma = token.get(CoreAnnotations.LemmaAnnotation.class);

					form = AnnotatorUtils.codeToParenthesis(form);
					lemma = AnnotatorUtils.codeToParenthesis(lemma);
					pos = AnnotatorUtils.codeToParenthesis(pos);

					forms.add(form);
					poss.add(pos);
					lemmas.add(lemma);
				}

				SentenceData09 localSentenceData091 = new SentenceData09();
				localSentenceData091.init(forms.toArray(new String[forms.size()]));
				localSentenceData091.setPPos(poss.toArray(new String[poss.size()]));

				SentenceData09 localSentenceData092;

				for (LKAnnotationEntity entity : dseLayer.entityList) {

					Span<Term> expressionSpan = getSpanFromEntity(entity, document);
					Span<Term> holderSpan = KAFDocument.newTermSpan();
//					Span<Term> targetSpan = KAFDocument.newTermSpan();

					if (expressionSpan.size() == 0) {
						LOGGER.debug("Expression span is empty [{}/{}]", nafFile.getName(), entity.localURI);
						continue;
					}

					Integer sentence = sentenceForSpan(expressionSpan);
					if (sentence == null) {
						LOGGER.warn("Expression span is not in sentence [{}/{}]", nafFile.getName(), entity.localURI);
						continue;
					}

					Opinion opinion = document.newOpinion();
					opinion.setLabel("gold-eu.fbk.dkm.pikes.resources.mpqa-subjective");

@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "", propOrder = {
    "value"
})
@XmlRootElement(name = "rel")
public class Rel {

    @XmlAttribute(name = "f")
    @XmlJavaTypeAdapter(NormalizedStringAdapter.class)
    protected String f;
    @XmlValue
    protected String value;

    /**
     * Recupera il valore della proprietà f.
     * 
     * @return
     *     possible object is
     *     {@link String }
     *     
     */
    public String getF() {
        return f;
    }

    /**
     * Imposta il valore della proprietà f.
     * 
     * @param value
     *     allowed object is
     *     {@link String }
     *     
     */
    public void setF(String value) {
        this.f = value;
    }

    /**
     * Recupera il valore della proprietà value.
     * 
     * @return
     *     possible object is
     *     {@link String }
     *     
     */
    public String getvalue() {
        return value;
    }

    /**
     * Imposta il valore della proprietà value.
     * 
     * @param value
     *     allowed object is
     *     {@link String }
     *     
     */
    public void setvalue(String value) {
        this.value = value;
    }

}

@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "", propOrder = {
    "value"
})
@XmlRootElement(name = "text")
public class Text {

    @XmlAttribute(name = "src")
    @XmlJavaTypeAdapter(NormalizedStringAdapter.class)
    protected String src;
    @XmlValue
    protected String value;

    /**
     * Recupera il valore della proprietà src.
     * 
     * @return
     *     possible object is
     *     {@link String }
     *     
     */
    public String getSrc() {
        return src;
    }

    /**
     * Imposta il valore della proprietà src.
     * 
     * @param value
     *     allowed object is
     *     {@link String }
     *     
     */
    public void setSrc(String value) {
        this.src = value;
    }

    /**
     * Recupera il valore della proprietà value.
     * 
     * @return
     *     possible object is
     *     {@link String }
     *     
     */
    public String getvalue() {
        return value;
    }

    /**
     * Imposta il valore della proprietà value.
     * 
     * @param value
     *     allowed object is
     *     {@link String }
     *     
     */
    public void setvalue(String value) {
        this.value = value;
    }

}

                .replaceAll("</?3>", "")
        );
        stringBuffer.append("\n</ROOT>\n");

        InputStream is = new ByteArrayInputStream(stringBuffer.toString().getBytes());
        DocumentBuilderFactory dbFactory = DocumentBuilderFactory.newInstance();
        DocumentBuilder dBuilder = dbFactory.newDocumentBuilder();
        Document doc = dBuilder.parse(is);

        doc.getDocumentElement().normalize();

        int i = 0;
        for (Element element : JOOX.$(doc).find("DOC")) {
            Element docnoElement = JOOX.$(element).find("DOCNO").get(0);
            Element dateElement = JOOX.$(element).find("DATE1").get(0);

                    logger.debug(naf);
                    if (naf != null) {
                        logger.info("Writing file " + outputFile);
                        Files.createParentDirs(outputFile);
                        try (Writer w = IO.utf8Writer(IO.buffer(IO.write(outputFile.getAbsolutePath())))) {
                            w.write(naf);
                        }
                    }

                } catch (final Throwable ex) {
                    logger.error(filename + " --- " + ex.getMessage());
                    markFileAsNotDone(filename);

                    try {
                        logger.info("Sleeping...");
                        Thread.sleep(sleepingTime);