G1

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.DoubleSummaryStatistics;

public class LogAnalyzer {

    public static Map<String, List<Integer>> parseLogFile(String filepath, Map<String, Pattern> regexPatterns) throws IOException {
        Map<String, List<Integer>> results = new HashMap<>();
        for (String description : regexPatterns.keySet()) {
            results.put(description, new ArrayList<>());
        }

        try (BufferedReader reader = new BufferedReader(new FileReader(filepath))) {
            String line;
            while ((line = reader.readLine()) != null) {
                for (Map.Entry<String, Pattern> entry : regexPatterns.entrySet()) {
                    String description = entry.getKey();
                    Pattern pattern = entry.getValue();
                    Matcher matcher = pattern.matcher(line);
                    if (matcher.find()) {
                        try {
                            // Extract the captured group (the millisecond value)
                           int timing = Integer.parseInt(matcher.group(1)); //For initialization
                            if(description.startsWith("DAO")){
                                timing = Integer.parseInt(matcher.group(2)); // DAO times are in group 2
                            }
                            results.get(description).add(timing);
                        } catch (NumberFormatException e) {
                            System.err.println("Warning: Could not convert to int: " + matcher.group(1));
                        }
                    }
                }
            }
        }
        return results;
    }

     public static void analyzeResults(Map<String, List<Integer>> resultsBefore, Map<String, List<Integer>> resultsAfter) {
        for (String description : resultsBefore.keySet()) {
            List<Integer> timingsBefore = resultsBefore.get(description);
            List<Integer> timingsAfter = resultsAfter.get(description);

            if (timingsBefore != null && !timingsBefore.isEmpty() && timingsAfter != null && !timingsAfter.isEmpty()) {
                DoubleSummaryStatistics statsBefore = timingsBefore.stream().mapToDouble(x -> x).summaryStatistics();
                DoubleSummaryStatistics statsAfter = timingsAfter.stream().mapToDouble(x -> x).summaryStatistics();


                System.out.println("Analysis for " + description + ":");
                System.out.printf("  Before: Count=%.0f, Mean=%.2f ms, Min=%.2f ms, Max=%.2f ms\n",
                        statsBefore.getCount(), statsBefore.getAverage(), statsBefore.getMin(), statsBefore.getMax());
                System.out.printf("  After:  Count=%.0f, Mean=%.2f ms, Min=%.2f ms, Max=%.2f ms\n",
                        statsAfter.getCount(), statsAfter.getAverage(), statsAfter.getMin(), statsAfter.getMax());

                // Calculate and display percentage change in mean
                double percentageChange = ((statsAfter.getAverage() - statsBefore.getAverage()) / statsBefore.getAverage()) * 100;
                System.out.printf("  Percentage Change (Mean): %.2f%%\n", percentageChange);


            } else {
                System.out.println("Analysis for " + description + ": Not enough data to compare.");
            }
        }
    }

    public static void main(String[] args) {
        // Define your regex patterns here.  MUST use Pattern.compile()
        Map<String, Pattern> regexPatterns = new HashMap<>();
        regexPatterns.put("Initialization", Pattern.compile("initialization completed in (\\d+) ms"));
        // DAO pattern:  Capture the method name AND the time.
        regexPatterns.put("DAO", Pattern.compile("\\*Time taken for\\*\\|(.*)\\|\\*is\\*=\\*(\\d+)\\*ms"));


        // Example usage with multiple files
        String[] beforeFiles = {"Jan29Log.txt"};  // Replace with your actual file paths
        String[] afterFiles = {"Feb27Log.txt"};      // Replace with your actual file paths

        try {
             // Aggregate results from multiple "before" files
            Map<String, List<Integer>> aggregatedBeforeResults = new HashMap<>();
             for (String description : regexPatterns.keySet()) {
                aggregatedBeforeResults.put(description, new ArrayList<>());
            }

            for (String file : beforeFiles) {
                Map<String, List<Integer>> fileResults = parseLogFile(file, regexPatterns);
                 for (Map.Entry<String, List<Integer>> entry : fileResults.entrySet()) {
                    aggregatedBeforeResults.get(entry.getKey()).addAll(entry.getValue()); //Combine
                }

            }

            // Aggregate results from multiple "after" files
             Map<String, List<Integer>> aggregatedAfterResults = new HashMap<>();
              for (String description : regexPatterns.keySet()) {
                aggregatedAfterResults.put(description, new ArrayList<>());
            }

            for (String file : afterFiles) {
                 Map<String, List<Integer>> fileResults = parseLogFile(file, regexPatterns);
                for (Map.Entry<String, List<Integer>> entry : fileResults.entrySet()) {
                    aggregatedAfterResults.get(entry.getKey()).addAll(entry.getValue());//Combine
                }
            }



            // Analyze the aggregated results
            analyzeResults(aggregatedBeforeResults, aggregatedAfterResults);

        } catch (IOException e) {
            System.err.println("Error processing log files: " + e.getMessage());
            e.printStackTrace();
        }
    }
}