/**
   * extract technical terms using C-value method
   *
   * @param phraseFile
   * @throws IOException
   */
  public static void extractTerm(String phraseFile) throws IOException {

    logger.log(Level.INFO, "*********Collecting and cleaning candidates. Please wait...");

    HashMap<Candidate, Integer> map =
        new HashMap<Candidate, Integer>(); // map candiates and their frequency
    String line = "";
    int percentComplete1 = 0;
    int i = 0;
    try {
      BufferedReader br = new BufferedReader(new FileReader(phraseFile));
      long size = br.lines().count();
      br = new BufferedReader(new FileReader(phraseFile));

      while ((line = br.readLine()) != null) {
        if (!line.equals("")) { // check empty line

          Candidate cand = new Candidate(line, line.split("\\s").length);

          if (map.containsKey(cand)) {
            map.put(cand, map.get(cand) + 1);
          } else map.put(cand, 1);
        }

        // reporting the progress
        i++;
        if (i * 100 / size > percentComplete1) {
          percentComplete1 = percentComplete1 + 1;
          logger.log(Level.INFO, percentComplete1 + " percent of temp candidates processed.");
        }
      }

    } catch (FileNotFoundException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    }

    logger.log(Level.INFO, "*********Removing unfrequent noun phrases. Please wait...");
    // List<Candidate> cleanedCand = new ArrayList<>();

    Candidate[] cleanedCand = map.keySet().toArray(new Candidate[map.size()]);

    List<Candidate> candidates = new ArrayList<>();

    for (Candidate c : cleanedCand) {
      if (map.get(c) >= 50) { // ignore phrases occurring less than 50 times in the corpus
        c.incrementFreq(map.get(c));
        candidates.add(c);
      }
    }

    Document doc = new Document("C:\\", "terms.txt");
    // doc.List(tokenizedSentenceList);

    CValueAlgortithm cvalue = new CValueAlgortithm();
    cvalue.init(doc); // initializes the algorithm for processing the desired document.
    ILinguisticFilter pFilter = new AdjPrepNounFilter(); // filter
    cvalue.addNewProcessingFilter(pFilter);
    ; // for example the AdjNounFilter
    logger.log(Level.INFO, "*********Cvalue algorithm is running...");
    cvalue.setCandidates(candidates); // set candidates to the algorithm
    cvalue.runAlgorithm(); // process the CValue algorithm with the provided filters

    doc.getTermList(); // get the results
    List<Term> termList = doc.getTermList();

    logger.log(Level.INFO, "*********Terms being written...");

    PrintWriter pw2 = new PrintWriter(new FileOutputStream(termFile));
    int k = 0;
    for (Term t : termList) {
      k++;
      pw2.println(t.toString());
    }
    pw2.close();

    logger.log(Level.INFO, "Terms are saved.");

    System.out.println("Top 20 technical terms:");

    for (int l = 0; l < 21; l++) System.out.println(termList.get(l).toString());
  }
  /**
   * extract a list of noun phrases and save it on the disk noun phrases with length > 10 are
   * ignored
   *
   * @throws IOException
   */
  public static void extractNounPhrases() throws IOException {

    /** initial declaration */
    List<String> nounPhrases = new ArrayList<>();
    File folder = new File(tagged_stemmedSingleDir);
    File[] listOfFiles = folder.listFiles();
    int filecount = listOfFiles.length;
    int i = 0;

    /**
     * scan the input folder that contains tokenized and tagged corpus extract noun phrases in
     * accordance with a pattern
     */
    logger.log(Level.INFO, "Data files are being read. Please wait...");
    for (File file : listOfFiles) {
      if (file.isFile()) {
        LinkedList<Token> tokenList = new LinkedList<>();

        List<LinkedList<Token>> tokenizedSentenceList = new ArrayList<LinkedList<Token>>();
        i++;
        String filepath = tagged_stemmedSingleDir + "\\" + file.getName();
        String combline = "";
        String line = "";
        try {
          BufferedReader br = new BufferedReader(new FileReader(filepath));

          while ((line = br.readLine()) != null) combline = combline + " " + line;

        } catch (FileNotFoundException e) {
          // TODO Auto-generated catch block
          e.printStackTrace();
        }

        logger.log(Level.INFO, "The array of tagged tokens are being generated. Please wait...");

        // remove duplicate spaces
        combline = combline.replaceAll("\\s+", " ").trim();

        // save string to array list
        List<String> tagged_tokens = Lists.newArrayList(combline.split(" "));

        logger.log(Level.INFO, "Tokenlist is being generated. Please wait...");
        int j = 0;
        String preToken = "";
        for (String t : tagged_tokens) {

          if (!t.equals("")
              && !t.equals(" ")
              && !t.equals(preToken)) { // ignore space, null or repeated tokens
            String token = t.substring(0, t.lastIndexOf("/"));
            String tag = t.substring(t.lastIndexOf("/") + 1);
            tokenList.add(new Token(token, tag));
            j++;
            preToken =
                tagged_tokens.get(j - 1); // to check repeated tokens that may not have meanings
          }
        }

        /** extracting noun phrases */
        tokenizedSentenceList.add(tokenList);

        Document doc = new Document("C:\\", "terms.txt");
        doc.List(tokenizedSentenceList);

        CValueAlgortithm cvalue = new CValueAlgortithm();
        cvalue.init(doc); // initializes the algorithm for processing the desired document.

        ILinguisticFilter pFilter = new AdjPrepNounFilter();
        cvalue.addNewProcessingFilter(pFilter);
        ; // set noun phrase pattern, e.g. AdjNounFilter

        List<String> cList = cvalue.extractCandidate(); // extract NP candidate

        nounPhrases.addAll(cList);

        logger.log(Level.INFO, "---------" + i + " out of " + filecount + " files processed------");
      }
    }

    /** writing noun phrases stemming */
    logger.log(Level.INFO, "*********Writting noun phrases. Please wait...");
    PrintWriter pw1 = new PrintWriter(new FileOutputStream(phraseFile));
    List<String> stemmedwords = new ArrayList<String>();
    PlingStemmer stemmer = new PlingStemmer();

    for (String c : nounPhrases) {

      /**
       * //stemming phrase List<String> words = Lists.newArrayList(c.split("\\s")); String
       * stemmedPhrase =""; if (words.size()<=10) //ignore noun phrases with length >10 for (String
       * w :words) { w=w.toLowerCase(); //lowercase phrase w=stemmer.stem(w); //stemming phrase
       * stemmedPhrase=stemmedPhrase+" " +w; } pw1.println(stemmedPhrase);
       */
      pw1.println(c);
    }
    pw1.close();

    logger.log(Level.INFO, "DONE!");
  }