// © 2016 and later: Unicode, Inc. and others.
// License & terms of use: http://www.unicode.org/copyright.html#License
/*
 *******************************************************************************
 * Copyright (C) 2016, International Business Machines Corporation and         *
 * others. All Rights Reserved.                                                *
 *******************************************************************************
 */
package com.ibm.icu.dev.tool.coverage;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.StringReader;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
import java.util.TreeSet;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;

import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.EntityResolver;
import org.xml.sax.InputSource;
import org.xml.sax.SAXException;

/**
 * A tool used for scanning JaCoCo report.xml and detect methods not covered by the
 * ICU4J unit tests. This tool is called from ICU4J ant target: coverageJaCoCo, and
 * signals failure if there are any methods with no test coverage (and not included
 * in 'coverage-exclusion.txt').
 */
public class JacocoReportCheck {
    public static void main(String... args) {
        if (args.length < 1) {
            System.err.println("Missing jacoco report.xml");
            System.exit(1);
        }

        System.out.println("Checking method coverage in " + args[0]);
        if (args.length > 1) {
            System.out.println("Coverage check exclusion file: " + args[1]);
        }

        File reportXml = new File(args[0]);
        Map<String, ReportEntry> entries = parseReport(reportXml);
        if (entries == null) {
            System.err.println("Failed to parse jacoco report.xml");
            System.exit(2);
        }

        Set<String> excludedSet = new HashSet<String>();
        if (args.length > 1) {
            File exclusionTxt = new File(args[1]);
            BufferedReader reader = null;
            try {
                reader = new BufferedReader(new InputStreamReader(new FileInputStream(exclusionTxt)));
                while (true) {
                    String line = reader.readLine();
                    if (line == null) {
                        break;
                    }
                    line = line.trim();
                    if (line.startsWith("//") || line.length() == 0) {
                        // comment or blank line
                        continue;
                    }
                    boolean added = excludedSet.add(line);
                    if (!added) {
                        System.err.println("Warning: Duplicated exclusion entry - " + line);
                    }
                }
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                if (reader != null) {
                    try {
                        reader.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                        // ignore
                    }
                }
            }
        }


        Set<String> noCoverageSet = new TreeSet<String>();
        Set<String> coveredButExcludedSet = new TreeSet<String>();

        for (ReportEntry reportEntry : entries.values()) {
            String key = reportEntry.key();
            Counter methodCnt = reportEntry.method().methodCounter();
            int methodMissed = methodCnt == null ? 1 : methodCnt.missed();
            if (methodMissed > 0) {
                // no test coverage
                if (!excludedSet.contains(key)) {
                    noCoverageSet.add(key);
                }
            } else {
                // covered
                if (excludedSet.contains(key)) {
                    coveredButExcludedSet.add(key);
                }
            }
        }

        if (noCoverageSet.size() > 0) {
            System.out.println("//");
            System.out.println("// Methods with no test coverage, not included in the exclusion set");
            System.out.println("//");
            for (String key : noCoverageSet) {
                System.out.println(key);
            }
        }

        if (coveredButExcludedSet.size() > 0) {
            System.out.println("//");
            System.out.println("// Methods covered by tests, but included in the exclusion set");
            System.out.println("//");
            for (String key : coveredButExcludedSet) {
                System.out.println(key);
            }
        }

        System.out.println("Method coverage check finished");

        if (noCoverageSet.size() > 0) {
            System.err.println("Error: Found method(s) with no test coverage");
            System.exit(-1);
        }
    }

    private static Map<String, ReportEntry> parseReport(File reportXmlFile) {
        try {
            Map<String, ReportEntry> entries = new TreeMap<String, ReportEntry>();
            DocumentBuilder docBuilder = DocumentBuilderFactory.newInstance().newDocumentBuilder();
            docBuilder.setEntityResolver(new EntityResolver() {
                // Ignores JaCoCo report DTD
                public InputSource resolveEntity(String publicId, String systemId) {
                    return new InputSource(new StringReader(""));
                }
            });
            Document doc = docBuilder.parse(reportXmlFile);
            NodeList nodes = doc.getElementsByTagName("report");
            for (int idx = 0; idx < nodes.getLength(); idx++) {
                Node node = nodes.item(idx);
                if (node.getNodeType() != Node.ELEMENT_NODE) {
                    continue;
                }
                Element reportElement = (Element)node;
                NodeList packages = reportElement.getElementsByTagName("package");
                for (int pidx = 0 ; pidx < packages.getLength(); pidx++) {
                    Node pkgNode = packages.item(pidx);
                    if (pkgNode.getNodeType() != Node.ELEMENT_NODE) {
                        continue;
                    }
                    Element pkgElement = (Element)pkgNode;
                    NodeList classes = pkgElement.getChildNodes();
                    if (classes == null) {
                        continue;
                    }

                    // Iterate through classes
                    for (int cidx = 0; cidx < classes.getLength(); cidx++) {
                        Node clsNode = classes.item(cidx);
                        if (clsNode.getNodeType() != Node.ELEMENT_NODE || !"class".equals(clsNode.getNodeName())) {
                            continue;
                        }
                        Element clsElement = (Element)clsNode;
                        String cls = clsElement.getAttribute("name");

                        NodeList methods = clsNode.getChildNodes();
                        if (methods == null) {
                            continue;
                        }

                        // Iterate through method elements
                        for (int midx = 0; midx < methods.getLength(); midx++) {
                            Node mtdNode = methods.item(midx);
                            if (mtdNode.getNodeType() != Node.ELEMENT_NODE || !"method".equals(mtdNode.getNodeName())) {
                                continue;
                            }
                            Element mtdElement = (Element)mtdNode;
                            String mtdName = mtdElement.getAttribute("name");
                            String mtdDesc = mtdElement.getAttribute("desc");
                            String mtdLineStr = mtdElement.getAttribute("line");
                            assert mtdName != null;
                            assert mtdDesc != null;
                            assert mtdLineStr != null;

                            int mtdLine = -1;
                            try {
                                 mtdLine = Integer.parseInt(mtdLineStr);
                            } catch (NumberFormatException e) {
                                // Ignore line # parse failure
                                e.printStackTrace();
                            }

                            // Iterate through counter elements and add report entries

                            Counter instructionCnt = null;
                            Counter branchCnt = null;
                            Counter lineCnt = null;
                            Counter complexityCnt = null;
                            Counter methodCnt = null;

                            NodeList counters = mtdNode.getChildNodes();
                            if (counters == null) {
                                continue;
                            }
                            for (int i = 0; i < counters.getLength(); i++) {
                                Node cntNode = counters.item(i);
                                if (cntNode.getNodeType() != Node.ELEMENT_NODE) {
                                    continue;
                                }
                                Element cntElement = (Element)cntNode;
                                String type = cntElement.getAttribute("type");
                                String missedStr = cntElement.getAttribute("missed");
                                String coveredStr = cntElement.getAttribute("covered");
                                assert type != null;
                                assert missedStr != null;
                                assert coveredStr != null;

                                int missed = -1;
                                int covered = -1;
                                try {
                                    missed = Integer.parseInt(missedStr);
                                } catch (NumberFormatException e) {
                                    // Ignore missed # parse failure
                                    e.printStackTrace();
                                }
                                try {
                                    covered = Integer.parseInt(coveredStr);
                                } catch (NumberFormatException e) {
                                    // Ignore covered # parse failure
                                    e.printStackTrace();
                                }

                                if (type.equals("INSTRUCTION")) {
                                    instructionCnt = new Counter(missed, covered);
                                } else if (type.equals("BRANCH")) {
                                    branchCnt = new Counter(missed, covered);
                                } else if (type.equals("LINE")) {
                                    lineCnt = new Counter(missed, covered);
                                } else if (type.equals("COMPLEXITY")) {
                                    complexityCnt = new Counter(missed, covered);
                                } else if (type.equals("METHOD")) {
                                    methodCnt = new Counter(missed, covered);
                                } else {
                                    System.err.println("Unknown counter type: " + type);
                                    // Ignore
                                }
                            }
                            // Add the entry
                            Method method = new Method(mtdName, mtdDesc, mtdLine,
                                    instructionCnt, branchCnt, lineCnt, complexityCnt, methodCnt);

                            ReportEntry entry = new ReportEntry(cls, method);
                            ReportEntry prev = entries.put(entry.key(), entry);
                            if (prev != null) {
                                System.out.println("oh");
                            }
                        }
                    }
                }
            }
            return entries;
        } catch (IOException e) {
            e.printStackTrace();
            return null;
        } catch (ParserConfigurationException e) {
            e.printStackTrace();
            return null;
        } catch (SAXException e) {
            e.printStackTrace();
            return null;
        }
    }

    private static class Counter {
        final int missed;
        final int covered;

        Counter(int missed, int covered) {
            this.missed = missed;
            this.covered = covered;
        }

        int missed() {
            return missed;
        }

        int covered() {
            return covered;
        }
    }

    private static class Method {
        final String name;
        final String desc;
        final int line;

        final Counter instructionCnt;
        final Counter branchCnt;
        final Counter lineCnt;
        final Counter complexityCnt;
        final Counter methodCnt;

        Method(String name, String desc, int line,
                Counter instructionCnt, Counter branchCnt, Counter lineCnt,
                Counter complexityCnt, Counter methodCnt) {
            this.name = name;
            this.desc = desc;
            this.line = line;
            this.instructionCnt = instructionCnt;
            this.branchCnt = branchCnt;
            this.lineCnt = lineCnt;
            this.complexityCnt = complexityCnt;
            this.methodCnt = methodCnt;
        }

        String name() {
            return name;
        }

        String desc() {
            return desc;
        }

        int line() {
            return line;
        }

        Counter instructionCounter() {
            return instructionCnt;
        }

        Counter branchCounter() {
            return branchCnt;
        }

        Counter lineCounter() {
            return lineCnt;
        }

        Counter complexityCounter() {
            return complexityCnt;
        }

        Counter methodCounter() {
            return methodCnt;
        }
    }

    private static class ReportEntry {
        final String cls;
        final Method method;
        final String key;

        ReportEntry(String cls, Method method) {
            this.cls = cls;
            this.method = method;
            this.key = cls + "#" + method.name() + ":" + method.desc();
        }

        String key() {
            return key;
        }

        String cls() {
            return cls;
        }

        Method method() {
            return method;
        }
    }

}