package com.frk.main;

import com.atlassian.clover.CloverDatabase;
import com.atlassian.clover.CodeType;
import com.atlassian.clover.CoverageData;
import com.atlassian.clover.CoverageDataSpec;
import com.atlassian.clover.api.registry.*;
import com.atlassian.clover.recorder.PerTestCoverage;
import com.atlassian.clover.registry.entities.FullBranchInfo;
import com.atlassian.clover.registry.entities.FullProjectInfo;
import com.atlassian.clover.registry.entities.PackageFragment;
import com.atlassian.clover.registry.entities.TestCaseInfo;

import java.io.PrintStream;
import java.util.BitSet;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Set;

/**
 * @date 2024/4/11
 */
public class ReadCloverDb {
    static BitSet bs;
    static double totalBranches = 0.0;
    static double coverageBranches = 0.0;
    static int originTestCase = 0;
    static HashMap<BranchInfo, TestCaseInfo> branchInfoTestCaseInfoHashMap = new HashMap<>();
    static HashSet<BranchInfo> allBranchInfo = new HashSet<>();
    static HashSet<TestCaseInfo> existTestCase = new HashSet<>();
    public static void main(String[] args) throws Exception {
        String s = "D:\\learn\\junit-test\\test\\solve\\EightQueens_1664963256377\\target\\clover\\clover.db";
        //String s = "D:\\learn\\junit-test\\openclover\\target\\clover\\clover.db";
        // read clover database together with coverage recording files, use time span=0 (latest build)
        CloverDatabase db = CloverDatabase.loadWithCoverage(s, new CoverageDataSpec());
        ProjectInfo projectInfo = db.getRegistry().getProject();
        FullProjectInfo model = db.getModel(CodeType.ALL);
        // print some project details
        CoverageData cd= db.getCoverageData();
        BitSet allHits = cd.getAllHits();
        bs = allHits;
        printProject(projectInfo, System.out, cd);
        System.out.println(coverageBranches / totalBranches * 100);
        System.out.println(allHits);
        // 原来的测试用例数量
        originTestCase = cd.getTests().size();
        System.out.println("原来的测试用例数量 " + originTestCase);
        // 约简后的测试用例数量：
        System.out.println("约简后的测试用例数量 " + existTestCase.size());
        System.out.println("约简后的分支覆盖率 " + branchInfoTestCaseInfoHashMap.size()/totalBranches * 100);
//        Map<TestCaseInfo, BitSet> map = cd.mapTestsAndCoverageForFile();


//        Set<TestCaseInfo> testsCovering = cd.getTestsCovering(model);
//        for (TestCaseInfo testCaseInfo : testsCovering) {
//            System.out.println();
//        }

//        System.out.println(allHits);
//        Set<TestCaseInfo> tests = cd.getTests();
//        for (TestCaseInfo test : tests) {
//            BitSet hitsFor = cd.getHitsFor(test);
//            System.out.println(test);
//            System.out.println(hitsFor);
//        }

    }

    private static void printProject(ProjectInfo db, PrintStream out, CoverageData cd) {
        for (PackageInfo packageInfo : db.getAllPackages()) {
            out.println("package: " + packageInfo.getName());
            for (FileInfo fileInfo : packageInfo.getFiles()) {
                out.println("\tfile: " + fileInfo.getName());
                for (ClassInfo classInfo : fileInfo.getClasses()) {
                    out.println("\t\tclass: " + classInfo.getName());
                    for (MethodInfo methodInfo : classInfo.getMethods()) {
                        out.println("\t\t\tmethod: " + methodInfo.getName());
                        for (BranchInfo branchInfo: methodInfo.getBranches()) {
                            allBranchInfo.add(branchInfo);
                            totalBranches += 1.0;
                            /*
                            这些bitset代表了分支的编号
                             */
                            System.out.println("\t\t\t\tbrach: " + branchInfo.getContext());
                            int startLine = branchInfo.getStartLine();
                            System.out.println("\t\t\t\t\tbranch Line: " + startLine);
                            FullBranchInfo fullBranchInfo = (FullBranchInfo) branchInfo;
                            Set<TestCaseInfo> testsCovering = cd.getTestsCovering(fullBranchInfo);
                            System.out.println("\t\t\t\t\tcoverage By: " + testsCovering);
                            if (!branchInfoTestCaseInfoHashMap.containsKey(branchInfo)) {
                                boolean hasTestCase = false;
                                for (TestCaseInfo testCaseInfo : testsCovering) {
                                    if (existTestCase.contains(testCaseInfo)) {
                                        branchInfoTestCaseInfoHashMap.put(branchInfo, testCaseInfo);
                                        hasTestCase = true;
                                        break;
                                    }
                                }
                                if (!hasTestCase && !testsCovering.isEmpty()) {
                                    TestCaseInfo testCaseInfo = testsCovering.iterator().next();
                                    branchInfoTestCaseInfoHashMap.put(branchInfo, testCaseInfo);
                                    existTestCase.add(testCaseInfo);
                                }
                            }
                            for (TestCaseInfo testCaseInfo : testsCovering) {
                                // 该分支之前记录没有被覆盖
                                BitSet hitsFor = cd.getHitsFor(testCaseInfo);
                                System.out.println("\t\t\t\t\ttestCaseInfo " +testCaseInfo.getTestName() +": " + hitsFor);
                            }

                            if (branchInfo.getHitCount() > 0) {
                                coverageBranches += 1.0;
                            }
//                            int dataIndex = branchInfo.getDataIndex();
//                            int len = branchInfo.getDataLength();
//                            System.out.println("\t\t\t\t\tcoverage: " +bs.get(dataIndex,dataIndex + len));


                        }
                    }

                }
            }
        }
    }
}