protected static String translatePath(String targetStr, HashSet<Integer> nodeSet) {
   HashMap<Integer, String> map = titleFinder.getTitle(nodeSet);
   logger.debug("mapSize:" + map.values().size());
   for (Integer key : map.keySet()) {
     logger.debug(key + " " + map.get(key));
     targetStr = targetStr.replaceAll(key.toString(), map.get(key));
   }
   Pattern r = Pattern.compile("[0-9]+[" + SEPEATOR + "\"]");
   Matcher m = r.matcher(targetStr);
   if (m.find()) {
     return null;
   }
   logger.debug(targetStr);
   return targetStr;
 }
public class PathTranslator {

  private static Logger logger = LogManager.getLogger(PathTranslator.class.getName());
  private static TitleFinder titleFinder = TitleFinder.getInstance();
  private static PatentTitleFinder patTitleFinder = PatentTitleFinder.getInstance();
  private static final String SEPEATOR = ",";

  public static void main(String[] args) {
    boolean retrieveDistinguishPaths = true;
    boolean retrieveOtherPaths = false;
    boolean isWiki = true;
    int otherPathNumber = 0;

    for (String arg : args) {
      if (arg.startsWith("-nd")) {
        retrieveDistinguishPaths = false;
      }
      if (arg.startsWith("-d")) {
        retrieveDistinguishPaths = true;
      }
      if (arg.startsWith("-o")) {
        otherPathNumber = Integer.parseInt(arg.replace("-o", ""));
        if (otherPathNumber > 0 && otherPathNumber < 50) { // a reasonable interval
          retrieveOtherPaths = true;

        } else {
          retrieveOtherPaths = false;
        }
      }
      if (arg.startsWith("-no")) {
        retrieveOtherPaths = false;
      }
      if (arg.startsWith("-p")) {
        isWiki = false;
      }
      if (arg.startsWith("-a")) {
        retrieveDistinguishPaths = true;
        otherPathNumber = -1;
        retrieveOtherPaths = true;
      }
    }

    if (isWiki) {
      txtPathLoader(
          "./data/allpath.txt",
          retrieveDistinguishPaths,
          retrieveOtherPaths,
          otherPathNumber,
          isWiki);
    } else {
      txtPathLoader(
          "./data/allpatentpath.txt",
          retrieveDistinguishPaths,
          retrieveOtherPaths,
          otherPathNumber,
          isWiki);
    }
  }

  protected static String trimPath(String path) {
    path = path.substring(0, path.indexOf(";") - 1).replace("]", "").replace("[", "");
    logger.debug(path);
    String[] nodes = path.split(",");
    if (nodes.length <= 2) {
      return null;
    }
    StringBuilder sb = new StringBuilder();
    sb.append("\"" + "->");
    for (int i = 1; i < nodes.length - 1; i++) {
      sb.append(nodes[i].trim());
      sb.append("->");
    }
    sb.append("\"");
    logger.debug(sb.toString());
    return sb.toString();
  }

  protected static void txtPathLoader(
      String path,
      boolean retrieveDistinguishPaths,
      boolean retrieveOtherPaths,
      int otherPathNumber,
      boolean isWiki) {
    try {
      BufferedReader bufferedReader = new BufferedReader(new FileReader(path));
      String line;
      int minSize = 0;
      PrintWriter writer = new PrintWriter("non_order.csv", "UTF-8");
      PrintWriter writerOrdered = new PrintWriter("ordered.csv", "UTF-8");

      // write header to files
      writer.println("start,end,path_1,path_2,path_3,path_4,path_5");
      writerOrdered.println("start,end,path_1,path_2,path_3,path_4,path_5");

      PrintWriter w = null;

      // mark its separator

      if (retrieveDistinguishPaths) {
        minSize += 2;
      }
      if (retrieveOtherPaths) {
        minSize += otherPathNumber;
      }

      if (otherPathNumber == -1) {
        minSize = 0;
      }

      line = bufferedReader.readLine();

      while (line != null && !line.isEmpty()) {
        if (line.startsWith("non-order") || line.startsWith("order")) {
          if (line.startsWith("non-order")) {
            w = writer;
          } else {
            w = writerOrdered;
          }
          int size = Integer.parseInt(line.split(",")[1]);
          if (size >= minSize) {
            HashSet<Integer> nodeSet = new HashSet<Integer>();
            LinkedList<String> pathList = new LinkedList<String>();
            StringBuilder stringBuilder = new StringBuilder();
            while (size > 0) {
              size--;
              line = bufferedReader.readLine();
              logger.debug(line);
              pathList.add(line.replace("],", "];"));
              String[] data = line.split("],");
              String[] nodes = data[0].replace("[", "").split(",");
              if (nodes.length <= 2) {
                pathList.pollLast();
              }
              for (String node : nodes) {
                nodeSet.add(Integer.parseInt(node.trim()));
              }
              if (stringBuilder.length() == 0) {
                stringBuilder.append("\"" + nodes[0].trim() + "\"" + SEPEATOR);
                stringBuilder.append("\"" + nodes[nodes.length - 1].trim() + "\"" + SEPEATOR);
              }
            }
            if (minSize == 0 && otherPathNumber == -1) {
              for (String pa : pathList) {
                stringBuilder.append(trimPath(pa));
                stringBuilder.append(SEPEATOR);
              }
              String s;
              if (isWiki) {
                s = translatePath(stringBuilder.toString(), nodeSet);
              } else {
                s = translatePatPath(stringBuilder.toString(), nodeSet);
              }
              if (s != null) {
                w.println(s);
              } else {
                System.out.println("empty string");
              }
            } else if (pathList.size() >= minSize) {
              if (retrieveDistinguishPaths) {
                stringBuilder.append(trimPath(pathList.pollFirst()));
                stringBuilder.append(SEPEATOR);
                stringBuilder.append(trimPath(pathList.pollLast()));
                stringBuilder.append(SEPEATOR);
              }
              if (retrieveOtherPaths) {
                int cnt = 1;
                if (pathList.size() == otherPathNumber) {
                  for (String pa : pathList) {
                    stringBuilder.append(trimPath(pa));
                    stringBuilder.append(SEPEATOR);
                  }
                } else {
                  while (cnt <= otherPathNumber) {
                    System.out.println(
                        "pathSize"
                            + pathList.size()
                            + "this size"
                            + ((pathList.size() - 1) * cnt / otherPathNumber));
                    stringBuilder.append(
                        trimPath(pathList.get((pathList.size() - 1) * cnt / otherPathNumber)));
                    stringBuilder.append(SEPEATOR);
                    cnt++;
                  }
                }
              }
              String s;
              if (isWiki) {
                s = translatePath(stringBuilder.toString(), nodeSet);
              } else {
                s = translatePatPath(stringBuilder.toString(), nodeSet);
              }
              if (s != null) {
                w.println(s);
              } else {
                System.out.println("empty string");
              }
            }

          } else {
            logger.warn("Size " + size + " is smaller than " + minSize);
            while (size > 0) {
              bufferedReader.readLine();
              size--;
            }
          }
        }
        line = bufferedReader.readLine();
      }

    } catch (FileNotFoundException e) {
      e.printStackTrace();
    } catch (IOException e) {
      e.printStackTrace();
    }
  }

  protected static String translatePatPath(String targetStr, HashSet<Integer> nodeSet) {
    HashMap<Integer, String> map = patTitleFinder.getTitle(nodeSet);
    logger.debug("mapSize:" + map.values().size());
    for (Integer key : map.keySet()) {
      logger.debug(key + " " + map.get(key));
      targetStr = targetStr.replaceAll(key.toString(), map.get(key));
    }
    Pattern r = Pattern.compile("[0-9]+[" + SEPEATOR + "\"]");
    Matcher m = r.matcher(targetStr);
    if (m.find()) {
      System.out.println("empty " + targetStr + " " + map);
      return null;
    }
    logger.debug(targetStr);
    return targetStr;
  }

  protected static String translatePath(String targetStr, HashSet<Integer> nodeSet) {
    HashMap<Integer, String> map = titleFinder.getTitle(nodeSet);
    logger.debug("mapSize:" + map.values().size());
    for (Integer key : map.keySet()) {
      logger.debug(key + " " + map.get(key));
      targetStr = targetStr.replaceAll(key.toString(), map.get(key));
    }
    Pattern r = Pattern.compile("[0-9]+[" + SEPEATOR + "\"]");
    Matcher m = r.matcher(targetStr);
    if (m.find()) {
      return null;
    }
    logger.debug(targetStr);
    return targetStr;
  }
}