//FileComparisonTool.cs
using System;
using System.Collections.Generic;
using System.Text;
using System.Threading.Tasks;
using System.IO;
using System.Linq;
using System.Security.Cryptography;
namespace ConsoleApp1_CompareFiles
{
    // 文件實體類
    public class FileInfoEntity
    {
        public Guid Id { get; set; }
        public MemoryStream Stream { get; set; }
        public string FileName { get; set; }
        public long FileSize { get; set; }
    }
    // 文件比較工具類
    public class FileComparisonTool
    {
        public static string[] GetAllFilesInFolder(string folderPath)
        {
            try
            {
                // 獲取當前文件夾下的所有文件
                string[] files = Directory.GetFiles(folderPath);
                // 獲取當前文件夾下的所有子文件夾
                string[] subFolders = Directory.GetDirectories(folderPath);
                foreach (string subFolder in subFolders)
                {
                    // 遞歸調用獲取子文件夾下的所有文件
                    string[] subFiles = GetAllFilesInFolder(subFolder);
                    files = files.Concat(subFiles).ToArray();
                }
                return files;
            }
            catch (Exception ex)
            {
                Console.WriteLine($"發(fā)生錯誤: {ex.Message}");
                return new string[0];
            }
        }
        // 計算文件哈希值
        private static string CalculateHash(Stream stream)
        {
            using (SHA256 sha256 = SHA256.Create())
            {
                byte[] hashBytes = sha256.ComputeHash(stream);
                return BitConverter.ToString(hashBytes).Replace("-", "").ToLowerInvariant();
            }
        }
        // 入參是兩個文件流，比較兩個文件
        public static bool CompareFiles(Stream stream1, Stream stream2)
        {
            stream1.Position = 0;
            stream2.Position = 0;
            string hash1 = CalculateHash(stream1);
            string hash2 = CalculateHash(stream2);
            return hash1 == hash2;
        }
        // 入參是兩個文件路徑，比較兩個文件
        public static bool CompareFiles(string filePath1, string filePath2)
        {
            using (FileStream stream1 = File.OpenRead(filePath1))
            using (FileStream stream2 = File.OpenRead(filePath2))
            {
                return CompareFiles(stream1, stream2);
            }
        }
        // 入參是文件路徑的數(shù)組，找出重復文件
        public static List<FileInfoEntity> FindDuplicateFiles(string[] filePaths)
        {
            var fileInfos = new List<FileInfoEntity>();
            foreach (var filePath in filePaths)
            {
                var fileInfo = new FileInfo(filePath);
                fileInfos.Add(new FileInfoEntity
                {
                    Id = Guid.NewGuid(),
                    FileName = filePath,
                    FileSize = fileInfo.Length
                });
            }
            var groups = fileInfos.GroupBy(f => f.FileSize);
            var duplicateFiles = new List<FileInfoEntity>();
            foreach (var group in groups)
            {
                if (group.Count() > 1)
                {
                    var hashes = new Dictionary<string, FileInfoEntity>();
                    foreach (var file in group)
                    {
                        using (FileStream stream = File.OpenRead(file.FileName))
                        {
                            string hash = CalculateHash(stream);
                            if (hashes.ContainsKey(hash))
                            {
                                if (!duplicateFiles.Contains(hashes[hash]))
                                {
                                    duplicateFiles.Add(hashes[hash]);
                                }
                                duplicateFiles.Add(file);
                            }
                            else
                            {
                                hashes[hash] = file;
                            }
                        }
                    }
                }
            }
            return duplicateFiles;
        }
        /*
        代碼說明
        FindDuplicateFilesGrouped 方法：
        首先遍歷傳入的文件路徑數(shù)組，將每個文件的信息（Id、FileName、FileSize）封裝到 FileInfoEntity 對象中，并添加到 fileInfos 列表。
        接著按文件大小對 fileInfos 進行分組，得到 sizeGroups。
        針對每個大小組，計算組內每個文件的哈希值，把具有相同哈希值的文件存到 hashGroups 字典里。
        最后，將 hashGroups 中包含多個文件的組添加到 duplicateFileGroups 列表，該列表即為最終按組返回的重復文件結果。
        通過這種方式，就能方便地找出所有重復文件，并將它們按組分類返回。
        */
        // 入參是文件路徑數(shù)組，按組返回重復文件
        public static List<List<FileInfoEntity>> FindDuplicateFilesGrouped(string[] filePaths)
        {
            var fileInfos = new List<FileInfoEntity>();
            foreach (var filePath in filePaths)
            {
                var fileInfo = new FileInfo(filePath);
                fileInfos.Add(new FileInfoEntity
                {
                    Id = Guid.NewGuid(),
                    FileName = filePath,
                    FileSize = fileInfo.Length
                });
            }
            var sizeGroups = fileInfos.GroupBy(f => f.FileSize);
            var duplicateFileGroups = new List<List<FileInfoEntity>>();
            foreach (var sizeGroup in sizeGroups)
            {
                if (sizeGroup.Count() > 1)
                {
                    var hashGroups = new Dictionary<string, List<FileInfoEntity>>();
                    foreach (var file in sizeGroup)
                    {
                        using (FileStream stream = File.OpenRead(file.FileName))
                        {
                            string hash = CalculateHash(stream);
                            if (!hashGroups.ContainsKey(hash))
                            {
                                hashGroups[hash] = new List<FileInfoEntity>();
                            }
                            hashGroups[hash].Add(file);
                        }
                    }
                    foreach (var hashGroup in hashGroups.Values)
                    {
                        if (hashGroup.Count > 1)
                        {
                            duplicateFileGroups.Add(hashGroup);
                        }
                    }
                }
            }
            return duplicateFileGroups;
        }
    }
}
 

// Program.cs
// See https://aka.ms/new-console-template for more information
using ConsoleApp1_CompareFiles;
Console.WriteLine("Hello, World!");
string[] filePaths = { 
    "C:\\Users\\Aa\\Desktop\\新建文件夾\\1.txt",
    "C:\\Users\\Aa\\Desktop\\新建文件夾\\2.txt",
    "C:\\Users\\Aa\\Desktop\\新建文件夾\\3.txt",
    "C:\\Users\\Aa\\Desktop\\新建文件夾\\4.xlsx",
    "C:\\Users\\Aa\\Desktop\\新建文件夾\\5.xlsx",
    "C:\\Users\\Aa\\Desktop\\新建文件夾\\6.docx",
    "C:\\Users\\Aa\\Desktop\\新建文件夾\\7.docx",
    "C:\\Users\\Aa\\Desktop\\新建文件夾\\8.jpeg",
    "C:\\Users\\Aa\\Desktop\\新建文件夾\\9.jpeg",
    "C:\\Users\\Aa\\Desktop\\新建文件夾\\捕獲 - 副本.PNG",
    "C:\\Users\\Aa\\Desktop\\新建文件夾\\捕獲.PNG",
    "C:\\Users\\Aa\\Desktop\\新建文件夾\\微信圖片_20250221165428.png",
};
string folderPath = @"C:\Users\Aa\Desktop\新建文件夾";
string[] allFiles = FileComparisonTool.GetAllFilesInFolder(folderPath);
var duplicateFileGroups = FileComparisonTool.FindDuplicateFilesGrouped(allFiles);
Console.WriteLine($"找到的重復文件組數(shù)量: {duplicateFileGroups.Count}");
foreach (var group in duplicateFileGroups)
{
    Console.WriteLine($"該組重復文件數(shù)量: {group.Count}");
    foreach (var file in group)
    {
        Console.WriteLine($"  文件 ID: {file.Id}, 文件名: {file.FileName}, 文件大小: {file.FileSize}");
    }
}