import java.io.*;
import java.util.*;
import java.util.stream.*; 
import java.text.SimpleDateFormat;

/*
Used to generate table of contents.
    - No args: generate GitHub table
    - args == 'wordpress', generate WordPress table.
    - args == 'review', generate Review Page
    - args == 'all', genereate both table
*/
public class GenerateCodeTable {
    private static String GIT_HUB_LINK = "https://github.com/awangdev/LintCode/blob/master/Java/";
    private static String NOT_AVAILABLE = "N/A";
    private static String LINTCODE_TOKEN = "[lint]";
    private static String TOOL_TOKEN = "[tool]";
    private static SimpleDateFormat DATE_FORMAT = new SimpleDateFormat("yyyy-MM-dd");
    /*
        TableRow, used to hold table object and sort by date.
    */
    private static class TableRow {
        private long date = 0;
        private String fileName;
        private String level;
        private String tutorialLink;
        private String timeComplexity;
        private String spaceComplexity;
        private String note;
        private List<String> tags;
        
        public TableRow(
            long date,
            String fileName,
            String level,
            String tutorialLink,
            String timeComplexity,
            String spaceComplexity,
            String note,
            List<String> tags) {
            this.date = date;
            this.fileName = fileName;
            this.level = level;
            this.timeComplexity = timeComplexity;
            this.spaceComplexity = spaceComplexity;
            this.tutorialLink = tutorialLink;
            this.note = note;
            this.tags = tags;
        }

        public String getLeetcodeNum() {
            String[] fileNameArr = fileName.split("\\.");
            if (LINTCODE_TOKEN.equals(fileNameArr[0].toLowerCase())) {
                return LINTCODE_TOKEN;
            }
            if (TOOL_TOKEN.equals(fileNameArr[0].toLowerCase())) {
                return TOOL_TOKEN;
            }
            try {
                Integer.parseInt(fileNameArr[0]);
                return fileNameArr[0];
            } catch(Exception e) {
                return NOT_AVAILABLE;
            }
        }

        public long getDate() {
            return this.date;
        }

        public String getFileName() {
            return this.fileName;
        }

        public String getLevel() {
            return this.level;
        }

        public String getTutorialLink() {
            return this.tutorialLink;
        }

        public String getNote() {
            return this.note;
        }

        public List<String> getTags() {
            return this.tags;
        }

        public String getTableComposedLine(int i) {
            Date date = new Date(this.date);
            return "|" + this.getLeetcodeNum() + "|[" + this.fileName + "](" + GIT_HUB_LINK + fileName.replace(" ", "%20")
                 + ")|" + this.level + "|" + this.tags + "|" + this.timeComplexity + "|" + this.spaceComplexity + "|Java|" + i + "|\n";
        }
    }

    public static String TUTORIAL_KEY_WORD = "tutorial:";
    public static String TAGS_KEY_WORD = "tags:";
    public static String TIME_KEY_WORD = "time:";
    public static String SPACE_KEY_WORD = "space:";
    public static void main(String[] args) {
        GenerateCodeTable gct = new GenerateCodeTable();   
        //Read Java Solution Folder
        File folder = new File("./Java");//"." = current path
        if (!folder.exists() || !folder.isDirectory()) {
            System.out.println("Check Directory:1");
            return;
        }
        File[] listOfFiles = folder.listFiles();
        if (listOfFiles == null) {
            System.out.println("Check Directory:2");
            return;
        }

        String outputContent = "";
        File outFile;
        
        if (args.length == 0){
            outputContent = gct.generateREADME(listOfFiles);
            gct.printTable("README.md", outputContent);
        } else if (args != null && args[0].contains("wordpress")) {//Wordpress
            outputContent = gct.generateWordPressPage(listOfFiles);
            gct.printTable("WordPress.txt", outputContent);
        } else if (args != null && args[0].contains("review")) {//Review Page
            outputContent = gct.generateReviewPage(listOfFiles);
            gct.printTable("ReviewPage.md", outputContent);
        } else if (args != null && args[0].contains("tags")) {//Wordpress
            outputContent = gct.generateTagREADME(listOfFiles);
            gct.printTable("TagREADME.md", outputContent);
        } else if (args != null && args[0].contains("all")) {
            outputContent = gct.generateREADME(listOfFiles);
            gct.printTable("README.md", outputContent);
            //outputContent = generateWordPressPage(listOfFiles);
            //printTable("WordPress.txt", outputContent);
            outputContent = gct.generateReviewPage(listOfFiles);
            gct.printTable("ReviewPage.md", outputContent);
            outputContent = gct.generateTagREADME(listOfFiles);
            gct.printTable("TagREADME.md", outputContent);
            outputContent = gct.generateTagReviewPage(listOfFiles);
            gct.printTable("TagReviewPage.md", outputContent);
            outputContent = gct.generateLevelReviewPage(listOfFiles);
            gct.printTable("LevelReviewPage.md", outputContent);
        }

        System.out.println("Mission Accomplished. Now go ahead and commit");
    }   

    /*
        Output the content into file
    */
    public void printTable(String fileName, String outputContent) {
        //System.out.println(outputContent);
        //Write to README.md
        try {   
            File outFile = new File(fileName);
            FileOutputStream fop = new FileOutputStream(outFile);
            byte[] contentInBytes = outputContent.getBytes();
            fop.write(contentInBytes);
            fop.flush();
            fop.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /*
        Generate Wordpress contents
    */
    public String generateWordPressPage(File[] listOfFiles) {
        //Assemble output
        String outputContent = "Java Solutions to algorithm problems from LintCode, LeetCode...etc.\n" +
        "<table>" +
            "<thead>" + 
            "<tr>" + 
            "<th align='center'>#</th>" + 
            "<th align='left'>Problem</th>" + 
            "<th align='center'>  Language</th>" + 
            "</tr>" +
            "</thead>" +
            "<tbody>";

        int count = 0;
        for (File file : listOfFiles) {
            if (file.getName().contains(".java")) {
                outputContent+= 
                "<tr>" + 
                    "<td align='center'>" + count + "</td>" +
                    "<td align='left'><a href='" + GIT_HUB_LINK + file.getName() + "'>" + file.getName() + "</a></td>" +
                    "<td align='center'>Java</td>" +
                "</tr>";
                count++;            
            }
        }   

        outputContent += "</tbody></table>";
        return outputContent;
    }


    /*
        Generate GitHub README contents
    */
    public String generateREADME(File[] listOfFiles) {
        //Assemble output
        String outputContent = "# Java Algorithm Problems\n\n" +
            "| Leetcode# | Problem     | Level  | Tags | Time | Space | Language | Sequence |\n" + 
            "|:---------:|:------------|:------:|:----:|-----:|------:|:--------:|---------:|\n";
        List<TableRow> tableRows = getTableRows(listOfFiles);
        for (int i = 0; i < tableRows.size(); i++) {
            outputContent += tableRows.get(i).getTableComposedLine(i);
        }
        return outputContent;
    }

    /* Generate the tags Table*/
    public String generateTagREADME(File[] listOfFiles) {
        String outputContent = generateTableOfContent("TagREADME.md") + "\n\n";
        String header = "| Leetcode# | Problem     | Level  | Tags | Time | Space | Language | Sequence |\n" + 
                        "|:---------:|:------------|:------:|:----:|-----:|------:|:--------:|---------:|\n";
        List<TableRow> tableRows = getTableRows(listOfFiles);
        Map<String, List<TableRow>> tagToRows = new HashMap<>();
        tableRows.forEach(tableRow -> {
            for (String tag: tableRow.getTags()) {
                if (tag == null || tag.length() == 0) {
                    continue;
                }
                if (!tagToRows.containsKey(tag)) {
                    tagToRows.put(tag, new ArrayList<TableRow>());
                }
                tagToRows.get(tag).add(tableRow);
            }
        });
        // Build View
        List<Map.Entry<String, List<TableRow>>> entries = new ArrayList<>(tagToRows.entrySet());
        entries.sort(Comparator.comparing(entry -> -entry.getValue().size()));

        for (Map.Entry<String, List<TableRow>> entry : entries) {
            StringBuffer sb = new StringBuffer(" \n \n \n## " + entry.getKey() + " (" + entry.getValue().size() + ")\n");
            sb.append(header);
            List<TableRow> entryTableRows = entry.getValue();
            entryTableRows.sort(Comparator.comparing(row -> String.join(",", row.getTags())));
            for (int i = 0; i < entryTableRows.size(); i++) {
                sb.append(entryTableRows.get(i).getTableComposedLine(i));
            }
            outputContent += sb.toString() + "\n\n\n";
        }
        return outputContent;
    }

    // Generate review files by tags
    public String generateTagReviewPage(File[] listOfFiles) {
        List<TableRow> tableRows = getTableRows(listOfFiles);
        Map<String, List<TableRow>> tagToRows = new HashMap<>();
        // Group by tags:
        tableRows.forEach(tableRow -> {
            for (String tag: tableRow.getTags()) {
                if (tag == null || tag.length() == 0) {
                    continue;
                }
                if (!tagToRows.containsKey(tag)) {
                    tagToRows.put(tag, new ArrayList<TableRow>());
                }
                tagToRows.get(tag).add(tableRow);
            }
        });
        // Build View
        String outputContent = "";
        for (Map.Entry<String, List<TableRow>> entry : tagToRows.entrySet()) {
            StringBuffer sb = new StringBuffer(" \n \n \n## " + entry.getKey() + " (" + entry.getValue().size() + ")\n");
            sb.append(buildReviewSection(entry.getValue()));
            outputContent += sb.toString() + "\n\n\n";
            printTable("review/" + entry.getKey() + ".md", sb.toString());
        }
        return outputContent;
    }

    // Generate review files by levels
    public String generateLevelReviewPage(File[] listOfFiles) {
        List<TableRow> tableRows = getTableRows(listOfFiles);
        Map<String, List<TableRow>> levelToRows = new HashMap<>();
        // Group by levels:
        tableRows.forEach(tableRow -> {
            String level = tableRow.getLevel();
            if (NOT_AVAILABLE.equals(tableRow.getLevel())) {
                level = "NA";
            }
            if (!levelToRows.containsKey(level)) {
                levelToRows.put(level, new ArrayList<TableRow>());
            }
            levelToRows.get(level).add(tableRow);
        });
        // Build View
        String outputContent = "";
        for (Map.Entry<String, List<TableRow>> entry : levelToRows.entrySet()) {
            StringBuffer sb = new StringBuffer(" \n \n \n## " + entry.getKey() + " (" + entry.getValue().size() + ")\n");
            sb.append(buildReviewSection(entry.getValue()));
            outputContent += sb.toString() + "\n\n\n";
            printTable("review/level/" + entry.getKey() + ".md", sb.toString());
        }
        return outputContent;
    }

    /*
        Generate Review Page contents
        Review Page content:
        1. Sequence
        2. Name
        3. Difficulty
        4. Summary of solution, key points.
    */
    public String generateReviewPage(File[] listOfFiles) {
        //Assemble output
        String outputContent = "# Review Page\n\n" + 
            "This page summarize the solutions of all problems. For thoughts,ideas written in English, refer to deach individual solution. \n" + 
            "New problems will be automatically updated once added.\n\n";
            
        List<TableRow> tableRows = getTableRows(listOfFiles);
        int count = 0;
        int countMiss = 0;
        outputContent += buildReviewSection(tableRows);
        return outputContent;
    }

    private String buildReviewSection(List<TableRow> tableRows) {
        int count = 0;
        int countMiss = 0;
        StringBuffer sb = new StringBuffer();
        for (TableRow tableRow: tableRows) {
            // Skip non-ready items
            if (NOT_AVAILABLE.equals(tableRow.getLevel())) {
                System.out.println(countMiss + ". [File not yet formatted]: " + tableRow.getFileName() + " [Skipping. Please revisit]");
                countMiss++;
                continue;
            }
            //System.out.println(count +  ". " + tableRow.getLevel() + " [File not yet formatted]: " + tableRow.getFileName());
            sb.append("**" + count + ". [" + tableRow.getFileName());
            sb.append("](" + GIT_HUB_LINK);
            sb.append(tableRow.getFileName().replace(" ", "%20") +")**");
            
            sb.append("      Level: " + tableRow.getLevel() + "      Tags: " + tableRow.getTags() + "\n");
            sb.append("      " + tableRow.getTutorialLink() + "\n");
            sb.append(tableRow.getNote() + "\n");
            sb.append("\n---\n\n");
            count++;
        }
        return sb.toString();
    }

    private List<TableRow> getTableRows(File[] listOfFiles) {
        List<TableRow> tableRows = new ArrayList<>();
        for (File file : listOfFiles) {
            if (file.getName().contains(".java")) {
                tableRows.add(getTableRow(file.getName()));
            }
        }
        List<TableRow> nonProcessedRows = tableRows.stream()
            .filter(tableRow -> tableRow.getLeetcodeNum().equals(NOT_AVAILABLE))
            .collect(Collectors.toList());
        List<TableRow> processedLeetCodeRows = tableRows.stream()
            .filter(tableRow -> !tableRow.getLeetcodeNum().equals(NOT_AVAILABLE)
                && !tableRow.getLeetcodeNum().equals(LINTCODE_TOKEN) && !tableRow.getLeetcodeNum().equals(TOOL_TOKEN)
            )
            .collect(Collectors.toList());
        List<TableRow> processedLintCodeRows = tableRows.stream()
            .filter(tableRow -> tableRow.getLeetcodeNum().equals(LINTCODE_TOKEN))
            .collect(Collectors.toList());
        List<TableRow> processedToolCodeRows = tableRows.stream()
            .filter(tableRow -> tableRow.getLeetcodeNum().equals(TOOL_TOKEN))
            .collect(Collectors.toList());
        Collections.sort(processedLeetCodeRows, Comparator.comparing(TableRow::getDate));
        Collections.sort(processedLintCodeRows, Comparator.comparing(TableRow::getDate));
        System.out.println("Non Reviewed Problems: " + nonProcessedRows.size()
            + ", Reviewed LeetCode Problems: " + processedLeetCodeRows.size()
            + ", Reviewed LintCode Problems: " + processedLintCodeRows.size());
        List<TableRow> output = new ArrayList<>();
        output.addAll(nonProcessedRows);
        output.addAll(processedLintCodeRows);
        output.addAll(processedToolCodeRows);
        output.addAll(processedLeetCodeRows);
        return output;
    }

    private TableRow getTableRow(String fileName) {
        TableRow tableRow = null;
        String tutorialLink = "";
        String calculatedLevel = NOT_AVAILABLE;
        String timeComplexity = "";
        String spaceComplexity = "";
        long timestamp = 0;
        List<String> tags = new ArrayList<>();

        // get timestamp of file
        File file = new File("Java/" + fileName);
        timestamp = file.lastModified();

        try {
            BufferedReader reader = new BufferedReader(new InputStreamReader(
                                          new FileInputStream("Java/" + fileName), "UTF-8"));
            // Get level
            String line = reader.readLine().trim();
            if (line.length() == 1 && !calculateLevel(line).isEmpty()){
                calculatedLevel = calculateLevel(line.toUpperCase());
                line = reader.readLine().trim();
            }

            // TODO: remove the legacy timestamp. 
            // Below are existing logic to parse timestamp. Remove when all timestamp is cleaned up.
            if (line.length() != 0) {
                try{
                    Long.parseLong(line);
                    line = reader.readLine().trim();
                } catch(Exception e){ }
            }

            // Get tutorial
            if (line.contains(TUTORIAL_KEY_WORD)) {
                tutorialLink = "[Link](" + line.substring(TUTORIAL_KEY_WORD.length()) + ")";
                line = reader.readLine().trim();
            }

            // Get Tags
            if (line.contains(TAGS_KEY_WORD)) {
                // Do something
                String tagLine = line.substring(TAGS_KEY_WORD.length());
                for (String tag : tagLine.split(",")) {
                    tags.add(tag.trim());
                }
                Collections.sort(tags);
                line = reader.readLine().trim();
            }

            // Get Time
            if (line.contains(TIME_KEY_WORD)) {
                timeComplexity = line.substring(6).trim(); // "time:"
                line = reader.readLine().trim();
            }

            // Get Space
            if (line.contains(SPACE_KEY_WORD)) {
                spaceComplexity = line.substring(7).trim(); // "space:"
            }

            // Get Note
            String note = "";
            while ((line = reader.readLine()) != null && !line.equals("```") && !line.equals("/*")) {
                note += line + "\n";
            }

            // Get result
            tableRow = new TableRow(timestamp, fileName, calculatedLevel, tutorialLink, timeComplexity, spaceComplexity, note, tags);
        } catch (Exception e) {
            System.err.format("IOException: %s%n. Filename: %s", e, fileName);
        }
        return tableRow;
    }

    private String calculateLevel(String level) {
        switch(level) {
            case "N" : 
                return "Naive";
            case "E" : 
                return "Easy";
            case "M" : 
                return "Medium";
            case "H" : 
                return "Hard";
            case "S" : 
                return "Super";
            case "R" : 
                return "Review";
        }
        return NOT_AVAILABLE;
    }

    // Build the table of contents of the page. Need to have 'gh-md-toc' installed
    private String generateTableOfContent(String fileName) {
        StringBuffer sb = new StringBuffer();
        try {
            Runtime rt = Runtime.getRuntime();
            String[] commands = {"./gh-md-toc", fileName};
            Process proc = rt.exec(commands);

            BufferedReader stdInput = new BufferedReader(new 
                 InputStreamReader(proc.getInputStream()));

            BufferedReader stdError = new BufferedReader(new 
                 InputStreamReader(proc.getErrorStream()));

            // read the output from the command
            System.out.println("Here is the standard output of the command:\n");
            String s = null;
            while ((s = stdInput.readLine()) != null) {
                if (!s.contains("[gh-md-toc]") && !s.contains("table-of-contents")) {
                    sb.append(s.trim() + "\n");
                }
            }

            // read any errors from the attempted command
            System.out.println("Here is the standard error of the command (if any):\n");
            while ((s = stdError.readLine()) != null) {
                System.out.println(s);
            }
        } catch (Exception e) {
            System.err.format("IOException: %s%n", e);
        }
        System.out.println(sb.toString());
        return sb.toString();
    }
}