Untitled

package org.example;

import java.io.File;
import java.util.HashMap;
import java.util.Map;

public class FolderComparison {

    public static void main(String[] args) {
        String folderAPath = "C:\\Users\\przem\\OneDrive\\Pulpit\\A";
        String folderBPath = "C:\\Users\\przem\\OneDrive\\Pulpit\\B";

        Map<String, FolderStats> folderAStats = analyzeFolder(new File(folderAPath));
        Map<String, FolderStats> folderBStats = analyzeFolder(new File(folderBPath));

        System.out.println("Folder A Analysis:");
        printFolderStats(folderAStats);

        System.out.println("Folder B Analysis:");
        printFolderStats(folderBStats);

        System.out.println("Comparison:");
        compareFolders(folderAStats, folderBStats);
    }

    private static Map<String, FolderStats> analyzeFolder(File folder) {
        Map<String, FolderStats> stats = new HashMap<>();
        if (folder.exists() && folder.isDirectory()) {
            analyzeFolderRecursive(folder, stats);
        }
        return stats;
    }

    private static void analyzeFolderRecursive(File folder, Map<String, FolderStats> stats) {
        File[] files = folder.listFiles();
        if (files != null) {
            for (File file : files) {
                if (file.isDirectory()) {
                    analyzeFolderRecursive(file, stats);
                } else {
                    String folderPath = folder.getAbsolutePath();
                    FolderStats folderStats = stats.getOrDefault(folderPath, new FolderStats());
                    folderStats.incrementFileCount();

                    String extension = getFileExtension(file);
                    folderStats.incrementExtensionCount(extension);

                    stats.put(folderPath, folderStats);
                }
            }
        }
    }

    private static String getFileExtension(File file) {
        String name = file.getName();
        int lastIndex = name.lastIndexOf('.');
        return (lastIndex == -1) ? "" : name.substring(lastIndex + 1).toLowerCase();
    }

    private static void printFolderStats(Map<String, FolderStats> stats) {
        stats.forEach((path, folderStats) -> {
            System.out.println("Folder: " + path);
            System.out.println("  File Count: " + folderStats.getFileCount());
            System.out.println("  Extensions: " + folderStats.getExtensionsCount());
        });
    }

    private static void compareFolders(Map<String, FolderStats> folderAStats, Map<String, FolderStats> folderBStats) {
        folderAStats.forEach((path, statsA) -> {
            FolderStats statsB = folderBStats.get(path);
            if (statsB == null) {
                System.out.println("Folder in A not in B: " + path);
            } else {
                System.out.println("Comparing folder: " + path);
                if (statsA.getFileCount() == statsB.getFileCount()) {
                    System.out.println("  File counts match: " + statsA.getFileCount());
                } else {
                    System.out.println("  File count mismatch: A = " + statsA.getFileCount() + ", B = " + statsB.getFileCount());
                }

                statsA.getExtensionsCount().forEach((ext, countA) -> {
                    int countB = statsB.getExtensionsCount().getOrDefault(ext, 0);
                    if (countA == countB) {
                        System.out.println("  Extension match: " + ext + " = " + countA);
                    } else {
                        System.out.println("  Extension mismatch for " + ext + ": A = " + countA + ", B = " + countB);
                    }
                });
            }
        });

        folderBStats.keySet().stream()
                .filter(path -> !folderAStats.containsKey(path))
                .forEach(path -> System.out.println("Folder in B not in A: " + path));
    }

    static class FolderStats {
        private int fileCount;
        private Map<String, Integer> extensionsCount;

        public FolderStats() {
            this.fileCount = 0;
            this.extensionsCount = new HashMap<>();
        }

        public void incrementFileCount() {
            this.fileCount++;
        }

        public void incrementExtensionCount(String extension) {
            this.extensionsCount.put(extension, this.extensionsCount.getOrDefault(extension, 0) + 1);
        }

        public int getFileCount() {
            return fileCount;
        }

        public Map<String, Integer> getExtensionsCount() {
            return extensionsCount;
        }
    }
}