using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Security.Cryptography;
using System.Threading.Tasks;
using UnityEditor;
using UnityEngine;

namespace ProjSG.Editor.UI
{
    public class AssetDuplicateCheck : EditorWindow
    {
        private Vector2 scrollPosition;
        private bool showSettings = true;
        private bool showResults = false;
        private bool showFullPath = false;
        
        private string[] searchFolders = new string[] { "Assets" };
        private string[] searchExtensions = new string[] { ".png", ".jpg", ".jpeg", ".tga", ".psd", ".tif", ".tiff" };
        private bool includeSubfolders = true;
        private bool compareByContent = true;
        private bool compareByName = false;
        private int minFileSize = 10;
        
        private Dictionary<string, List<string>> duplicateGroups = new Dictionary<string, List<string>>();
        private int totalFilesScanned = 0;
        private int totalDuplicatesFound = 0;
        private long totalSpaceSaved = 0;
        
        private bool keepNewestFiles = true;
        private bool createBackup = true;
        private string backupFolder = "";
        private Dictionary<string, bool> selectedForRemoval = new Dictionary<string, bool>();
        
        private bool isProcessing = false;
        private float progress = 0f;
        private string progressInfo = "";

        [MenuItem("工具/资源管理/资源查重工具")]
        public static void ShowWindow()
        {
            AssetDuplicateCheck window = GetWindow<AssetDuplicateCheck>("资源查重工具");
            window.minSize = new Vector2(600, 400);
            window.Show();
        }

        private string GetAssetPath(string filePath)
        {
            string fullPath = Path.GetFullPath(filePath);
            string projectDataPath = Path.GetFullPath(Application.dataPath);

            if (fullPath.StartsWith(projectDataPath, StringComparison.OrdinalIgnoreCase))
            {
                return "Assets" + fullPath.Substring(projectDataPath.Length).Replace('\\', '/');
            }
            
            string projectRootPath = Path.GetFullPath(Path.Combine(Application.dataPath, ".."));
            if (fullPath.StartsWith(projectRootPath, StringComparison.OrdinalIgnoreCase))
            {
                string relativeToProjectRoot = fullPath.Substring(projectRootPath.Length);
                if (relativeToProjectRoot.StartsWith("/") || relativeToProjectRoot.StartsWith("\\"))
                {
                    relativeToProjectRoot = relativeToProjectRoot.Substring(1);
                }
                return relativeToProjectRoot.Replace('\\', '/');
            }

            Debug.LogWarning($"路径 '{filePath}' 无法可靠地转换为项目相对的资产路径。将返回原始路径（已规范化斜杠）。");
            return filePath.Replace('\\', '/');
        }

        private void OnGUI()
        {
            GUILayout.Label("资源查重工具", EditorStyles.boldLabel);
            EditorGUILayout.Space();

            scrollPosition = EditorGUILayout.BeginScrollView(scrollPosition);

            showSettings = EditorGUILayout.Foldout(showSettings, "搜索设置", true);
            if (showSettings)
            {
                DrawSettings();
            }

            EditorGUILayout.Space();

            if (duplicateGroups.Count > 0)
            {
                showResults = EditorGUILayout.Foldout(showResults, $"搜索结果 (找到 {totalDuplicatesFound} 个重复资源，可节省 {totalSpaceSaved / 1024f:F2} MB)", true);
                if (showResults)
                {
                    DrawResults();
                }
            }

            EditorGUILayout.EndScrollView();

            EditorGUILayout.Space();

            if (isProcessing)
            {
                EditorGUI.ProgressBar(EditorGUILayout.GetControlRect(false, 20f), progress, progressInfo);
                if (GUILayout.Button("取消"))
                {
                    isProcessing = false;
                }
            }
            else
            {
                EditorGUILayout.BeginHorizontal();
                if (GUILayout.Button("扫描重复资源", GUILayout.Height(30)))
                {
                    FindDuplicateAssets();
                }

                GUI.enabled = duplicateGroups.Count > 0;
                if (GUILayout.Button("处理选中的重复资源", GUILayout.Height(30)))
                {
                    ProcessDuplicateAssets();
                }
                GUI.enabled = true;
                EditorGUILayout.EndHorizontal();
            }
        }

        private void DrawSettings()
        {
            EditorGUI.indentLevel++;

            EditorGUILayout.LabelField("搜索文件夹:");
            EditorGUILayout.BeginHorizontal();
            string displaySearchFolder = searchFolders.Length > 0 ? searchFolders[0] : "Assets";
            EditorGUILayout.SelectableLabel(displaySearchFolder, EditorStyles.textField, GUILayout.Height(EditorGUIUtility.singleLineHeight));
            
            if (GUILayout.Button("选择文件夹", GUILayout.Width(100)))
            {
                string folderPath = EditorUtility.OpenFolderPanel("选择要搜索的文件夹", Application.dataPath, "");
                if (!string.IsNullOrEmpty(folderPath))
                {
                    string relativePath = GetAssetPath(folderPath);
                    if (!string.IsNullOrEmpty(relativePath) && 
                        (relativePath.StartsWith("Assets", StringComparison.OrdinalIgnoreCase) || 
                         relativePath.StartsWith("Packages", StringComparison.OrdinalIgnoreCase) || 
                         Directory.Exists(Path.Combine(Path.GetFullPath(Path.Combine(Application.dataPath, "..")), relativePath))))
                    {
                        searchFolders = new string[] { relativePath };
                    }
                    else
                    {
                        Debug.LogWarning($"选择的文件夹 '{folderPath}' 不在项目 Assets 或 Packages 内，或无法转换为有效的项目相对路径。");
                    }
                }
            }
            EditorGUILayout.EndHorizontal();

            EditorGUILayout.LabelField("文件类型:");
            string extensionsString = string.Join(", ", searchExtensions);
            extensionsString = EditorGUILayout.TextField(extensionsString);
            searchExtensions = extensionsString.Split(new char[] { ',', ' ' }, StringSplitOptions.RemoveEmptyEntries)
                .Select(e => e.Trim().ToLower())
                .Select(e => e.StartsWith(".") ? e : "." + e)
                .Distinct()
                .ToArray();

            EditorGUILayout.Space();
            EditorGUILayout.LabelField("搜索选项:");
            includeSubfolders = EditorGUILayout.Toggle("包含子文件夹", includeSubfolders);
            compareByContent = EditorGUILayout.Toggle("按内容比较", compareByContent);
            compareByName = EditorGUILayout.Toggle("按名称比较", compareByName);
            minFileSize = EditorGUILayout.IntField("最小文件大小 (KB)", minFileSize);
            
            EditorGUILayout.Space();
            EditorGUILayout.LabelField("处理选项:");
            keepNewestFiles = EditorGUILayout.Toggle("保留最新文件", keepNewestFiles);
            createBackup = EditorGUILayout.Toggle("创建备份", createBackup);
            
            if (createBackup)
            {
                EditorGUILayout.BeginHorizontal();
                backupFolder = EditorGUILayout.TextField("备份文件夹:", backupFolder);
                if (GUILayout.Button("浏览", GUILayout.Width(60)))
                {
                    string path = EditorUtility.OpenFolderPanel("选择备份文件夹", backupFolder, "");
                    if (!string.IsNullOrEmpty(path))
                    {
                        backupFolder = path;
                    }
                }
                EditorGUILayout.EndHorizontal();
            }

            EditorGUI.indentLevel--;
        }

        private void DrawResults()
        {
            EditorGUI.indentLevel++;
            
            EditorGUILayout.BeginHorizontal();
            showFullPath = EditorGUILayout.Toggle("显示完整路径", showFullPath);
            
            GUILayout.FlexibleSpace();
            
            if (GUILayout.Button("全选", GUILayout.Width(60)))
            {
                SelectAll(true);
            }
            
            if (GUILayout.Button("全不选", GUILayout.Width(60)))
            {
                SelectAll(false);
            }
            
            if (GUILayout.Button("智能选择", GUILayout.Width(80)))
            {
                SmartSelect();
            }
            
            EditorGUILayout.EndHorizontal();
            
            EditorGUILayout.Space();
            
            int groupIndex = 0;
            foreach (var group in duplicateGroups)
            {
                if (group.Value.Count <= 1) continue;
                
                groupIndex++;
                EditorGUILayout.BeginVertical(GUI.skin.box);
                
                string groupTitle = $"组 {groupIndex}: {group.Value.Count} 个文件";
                if (group.Value.Count > 0)
                {
                    string fileName = Path.GetFileName(group.Value[0]);
                    groupTitle += $" - {fileName}";
                }
                
                EditorGUILayout.LabelField(groupTitle, EditorStyles.boldLabel);
                
                foreach (string filePath in group.Value)
                {
                    EditorGUILayout.BeginHorizontal();
                    
                    bool isSelected = false;
                    if (selectedForRemoval.ContainsKey(filePath))
                    {
                        isSelected = selectedForRemoval[filePath];
                    }
                    
                    bool newSelected = EditorGUILayout.Toggle(isSelected, GUILayout.Width(20));
                    if (newSelected != isSelected)
                    {
                        selectedForRemoval[filePath] = newSelected;
                    }
                    
                    string displayPath = showFullPath ? filePath : Path.GetFileName(filePath);
                    
                    FileInfo fileInfo = new FileInfo(Path.Combine(Application.dataPath, "..", filePath));
                    string fileDetails = $"{displayPath} - {fileInfo.Length / 1024} KB";
                    
                    if (fileInfo.Exists)
                    {
                        fileDetails += $" - {fileInfo.LastWriteTime.ToString("yyyy-MM-dd HH:mm:ss")}";
                    }
                    
                    EditorGUILayout.LabelField(fileDetails);
                    
                    if (GUILayout.Button("选择", GUILayout.Width(60)))
                    {
                        Selection.activeObject = AssetDatabase.LoadAssetAtPath<UnityEngine.Object>(filePath);
                    }
                    
                    EditorGUILayout.EndHorizontal();
                }
                
                EditorGUILayout.EndVertical();
                EditorGUILayout.Space();
            }
            
            EditorGUI.indentLevel--;
        }

        private void SelectAll(bool select)
        {
            foreach (var group in duplicateGroups)
            {
                if (group.Value.Count <= 1) continue;
                
                foreach (string filePath in group.Value)
                {
                    selectedForRemoval[filePath] = select;
                }
            }
        }

        private void SmartSelect()
        {
            foreach (var group in duplicateGroups)
            {
                if (group.Value.Count <= 1) continue;
                
                string fileToKeep = null;
                
                if (keepNewestFiles)
                {
                    fileToKeep = group.Value
                        .OrderByDescending(f => File.GetLastWriteTime(Path.Combine(Application.dataPath, "..", f)))
                        .FirstOrDefault();
                }
                else
                {
                    fileToKeep = group.Value.FirstOrDefault();
                }
                
                foreach (string filePath in group.Value)
                {
                    selectedForRemoval[filePath] = (filePath != fileToKeep);
                }
            }
        }

        // 计算文件的MD5哈希值
        private string GetFileHash(string filePath)
        {
            try
            {
                using (var md5 = MD5.Create())
                using (var stream = File.OpenRead(filePath))
                {
                    byte[] hash = md5.ComputeHash(stream);
                    return BitConverter.ToString(hash).Replace("-", "").ToLowerInvariant();
                }
            }
            catch (Exception ex)
            {
                Debug.LogError($"计算文件哈希值时出错: {filePath}, {ex.Message}");
                return string.Empty;
            }
        }

        private async void FindDuplicateAssets()
        {
            isProcessing = true;
            progress = 0f;
            progressInfo = "正在收集文件...";
            
            // 清空之前的结果
            duplicateGroups.Clear();
            selectedForRemoval.Clear();
            totalFilesScanned = 0;
            totalDuplicatesFound = 0;
            totalSpaceSaved = 0;
            
            try
            {
                // 收集所有文件
                List<string> allFiles = new List<string>();
                foreach (string folder in searchFolders)
                {
                    if (string.IsNullOrEmpty(folder)) continue;
                    
                    string fullPath = Path.Combine(Application.dataPath, "..", folder);
                    if (!Directory.Exists(fullPath)) continue;
                    
                    string[] files = Directory.GetFiles(fullPath, "*.*", includeSubfolders ? SearchOption.AllDirectories : SearchOption.TopDirectoryOnly)
                        .Where(f => searchExtensions.Contains(Path.GetExtension(f).ToLower()))
                        .Select(f => GetAssetPath(f))
                        .ToArray();
                    
                    allFiles.AddRange(files);
                }
                
                totalFilesScanned = allFiles.Count;
                progressInfo = $"找到 {totalFilesScanned} 个文件，正在分析...";
                progress = 0.1f;
                Repaint();
                
                // 按内容或名称分组
                Dictionary<string, List<string>> groups = new Dictionary<string, List<string>>();
                
                for (int i = 0; i < allFiles.Count; i++)
                {
                    string filePath = allFiles[i];
                    string fullPath = Path.Combine(Application.dataPath, "..", filePath);
                    
                    // 检查文件大小
                    FileInfo fileInfo = new FileInfo(fullPath);
                    if (!fileInfo.Exists || fileInfo.Length < minFileSize * 1024) continue;
                    
                    string key = "";
                    
                    if (compareByContent)
                    {
                        // 计算文件哈希值
                        key = GetFileHash(fullPath);
                    }
                    else if (compareByName)
                    {
                        // 使用文件名作为键
                        key = Path.GetFileNameWithoutExtension(filePath);
                    }
                    
                    if (string.IsNullOrEmpty(key)) continue;
                    
                    if (!groups.ContainsKey(key))
                    {
                        groups[key] = new List<string>();
                    }
                    
                    groups[key].Add(filePath);
                    
                    // 更新进度
                    if (i % 10 == 0)
                    {
                        progress = 0.1f + 0.8f * ((float)i / allFiles.Count);
                        progressInfo = $"正在分析文件 {i+1}/{allFiles.Count}...";
                        Repaint();
                        await Task.Delay(1);
                    }
                }
                
                // 过滤出重复组
                foreach (var group in groups)
                {
                    if (group.Value.Count > 1)
                    {
                        duplicateGroups[group.Key] = group.Value;
                        totalDuplicatesFound += group.Value.Count - 1;
                        
                        // 计算可节省空间
                        string firstFile = group.Value[0];
                        string fullPath = Path.Combine(Application.dataPath, "..", firstFile);
                        FileInfo fileInfo = new FileInfo(fullPath);
                        if (fileInfo.Exists)
                        {
                            totalSpaceSaved += (group.Value.Count - 1) * fileInfo.Length / 1024;
                        }
                    }
                }
                
                progressInfo = $"分析完成，找到 {totalDuplicatesFound} 个重复资源";
                progress = 1f;
                Repaint();
                
                // 自动选择
                if (duplicateGroups.Count > 0)
                {
                    SmartSelect();
                }
            }
            catch (Exception ex)
            {
                Debug.LogError($"查找重复资源时出错: {ex.Message}\n{ex.StackTrace}");
                EditorUtility.DisplayDialog("错误", $"查找重复资源时出错: {ex.Message}", "确定");
            }
            finally
            {
                isProcessing = false;
                Repaint();
            }
        }

        private async void ProcessDuplicateAssets()
        {
            isProcessing = true;
            progress = 0f;
            progressInfo = "正在准备处理...";
            Repaint();

            // 统计要处理的文件数量
            int totalToProcess = selectedForRemoval.Count(pair => pair.Value);
            if (totalToProcess == 0)
            {
                EditorUtility.DisplayDialog("提示", "没有选择任何文件进行处理", "确定");
                isProcessing = false;
                return;
            }
            
            // 确认操作
            bool confirm = EditorUtility.DisplayDialog("确认操作", 
                $"将处理 {totalToProcess} 个重复资源。\n" +
                (createBackup ? $"备份将保存到: {backupFolder}" : "不创建备份") +
                "\n\n此操作不可撤销，是否继续？", 
                "继续", "取消");
                
            if (!confirm)
            {
                isProcessing = false;
                return;
            }
            
            try
            {
                // 处理每个重复组
                foreach (var group in duplicateGroups)
                {
                    if (group.Value.Count <= 1) continue;
                    
                    // 找出要保留的文件（通常是最新的文件）
                    string keepFile = null;
                    if (keepNewestFiles)
                    {
                        keepFile = group.Value
                            .OrderByDescending(f => new FileInfo(Path.Combine(Application.dataPath, "..", f)).LastWriteTime)
                            .FirstOrDefault();
                    }
                    else
                    {
                        // 如果不是保留最新的，则保留第一个未被选中删除的文件
                        keepFile = group.Value.FirstOrDefault(f => !selectedForRemoval.ContainsKey(f) || !selectedForRemoval[f]);
                    }
                    
                    // 如果没有找到要保留的文件，跳过这个组
                    if (string.IsNullOrEmpty(keepFile)) 
                    {
                        throw new Exception("没有找到要保留的文件");
                        continue;
                    }
                    // 处理这个组中的其他文件
                    foreach (string filePath in group.Value)
                    {
                        if (filePath == keepFile) continue;
                        
                        // 检查是否选中了这个文件进行删除
                        if (!selectedForRemoval.ContainsKey(filePath) || !selectedForRemoval[filePath]) continue;
                        
                        // 更新引用关系，将引用从filePath重定向到keepFile
                        UpdateReferences(filePath, keepFile);
                        
                        // ... existing code ...
                        
                        // 创建备份和删除文件的代码
                    }
                }

                // 刷新资源数据库
                AssetDatabase.Refresh();

                // 创建备份文件夹
                if (createBackup && !string.IsNullOrEmpty(backupFolder))
                {
                    Directory.CreateDirectory(backupFolder);
                }
                
                // 收集要删除的文件和保留的文件
                List<string> filesToRemove = new List<string>();
                Dictionary<string, string> fileReplaceMap = new Dictionary<string, string>();
                
                var tempGroups = new Dictionary<string, List<string>>(duplicateGroups);
                var tempRemoval = new Dictionary<string, bool>(selectedForRemoval);

                // 清空结果数据
                duplicateGroups.Clear();
                selectedForRemoval.Clear();
                totalFilesScanned = 0;
                totalDuplicatesFound = 0;
                totalSpaceSaved = 0;
                showResults = false;

                foreach (var group in tempGroups)
                {
                    if (group.Value.Count <= 1) continue;
                    
                    // 找出要保留的文件
                    string fileToKeep = null;
                    
                    foreach (string filePath in group.Value)
                    {
                        if (!tempRemoval.ContainsKey(filePath) || !tempRemoval[filePath])
                        {
                            fileToKeep = filePath;
                            break;
                        }
                    }
                    
                    // 如果所有文件都被标记为删除，保留第一个
                    if (string.IsNullOrEmpty(fileToKeep) && group.Value.Count > 0)
                    {
                        if (keepNewestFiles)
                        {
                            // 按最后修改时间排序，保留最新的
                            fileToKeep = group.Value
                                .OrderByDescending(f => File.GetLastWriteTime(Path.Combine(Application.dataPath, "..", f)))
                                .FirstOrDefault();
                        }
                        else
                        {
                            fileToKeep = group.Value[0];
                        }
                        
                        if (tempRemoval.ContainsKey(fileToKeep))
                        {
                            tempRemoval[fileToKeep] = false;
                        }
                    }
                    
                    // 收集要删除的文件
                    foreach (string filePath in group.Value)
                    {
                        if (filePath != fileToKeep && tempRemoval.ContainsKey(filePath) && tempRemoval[filePath])
                        {
                            filesToRemove.Add(filePath);
                            fileReplaceMap[filePath] = fileToKeep;
                        }
                    }
                }
                
                // 处理文件
                int processed = 0;
                foreach (string filePath in filesToRemove)
                {
                    processed++;
                    progress = (float)processed / totalToProcess;
                    progressInfo = $"正在处理 {processed}/{totalToProcess}: {Path.GetFileName(filePath)}";
                    Repaint();
                    
                    try
                    {
                        // 备份文件
                        if (createBackup && !string.IsNullOrEmpty(backupFolder))
                        {
                            string backupPath = Path.Combine(backupFolder, Path.GetFileName(filePath));
                            File.Copy(Path.Combine(Application.dataPath, "..", filePath), backupPath, true);
                        }
                        
                        // 更新引用
                        if (fileReplaceMap.ContainsKey(filePath))
                        {
                            UpdateReferences(filePath, fileReplaceMap[filePath]);
                        }
                        
                        // 删除文件
                        AssetDatabase.DeleteAsset(filePath);
                        
                        await Task.Delay(1);
                    }
                    catch (Exception ex)
                    {
                        Debug.LogError($"处理文件时出错: {filePath}, {ex.Message}");
                    }
                }
                
                // 刷新资源数据库
                AssetDatabase.Refresh();
                

                
                // 完成
                progressInfo = $"处理完成，已处理 {processed} 个文件";
                progress = 1f;
                EditorUtility.DisplayDialog("完成", $"已处理 {processed} 个重复资源", "确定");
            }
            catch (Exception ex)
            {
                Debug.LogError($"处理重复资源时出错: {ex.Message}\n{ex.StackTrace}");
                EditorUtility.DisplayDialog("错误", $"处理重复资源时出错: {ex.Message}", "确定");
            }
            finally
            {
                isProcessing = false;
                Repaint();
            }
        }

        // 更新引用关系
        private void UpdateReferences(string oldPath, string newPath)
        {
            string[] guids = AssetDatabase.FindAssets("t:Object");
            
            foreach (string guid in guids)
            {
                string assetPath = AssetDatabase.GUIDToAssetPath(guid);
                
                if (assetPath == oldPath || assetPath == newPath) continue;
                
                if (!assetPath.EndsWith(".asset") && !assetPath.EndsWith(".prefab") && !assetPath.EndsWith(".unity") && !assetPath.EndsWith(".mat"))
                    continue;
                
                UnityEngine.Object obj = AssetDatabase.LoadAssetAtPath<UnityEngine.Object>(assetPath);
                if (obj == null) continue;
                
                string[] dependencies = AssetDatabase.GetDependencies(assetPath, false);
                if (dependencies.Contains(oldPath))
                {
                    // 获取旧资源和新资源
                    UnityEngine.Object oldAsset = AssetDatabase.LoadAssetAtPath<UnityEngine.Object>(oldPath);
                    UnityEngine.Object newAsset = AssetDatabase.LoadAssetAtPath<UnityEngine.Object>(newPath);
                    
                    if (oldAsset != null && newAsset != null)
                    {
                        // 使用SerializedObject更新引用
                        SerializedObject serializedObj = new SerializedObject(obj);
                        bool modified = false;
                        
                        SerializedProperty iterator = serializedObj.GetIterator();
                        while (iterator.NextVisible(true))
                        {
                            if (iterator.propertyType == SerializedPropertyType.ObjectReference && 
                                iterator.objectReferenceValue == oldAsset)
                            {
                                iterator.objectReferenceValue = newAsset;
                                modified = true;
                            }
                        }
                        
                        if (modified)
                        {
                            serializedObj.ApplyModifiedProperties();
                            Debug.Log($"已更新资源 {assetPath} 中的引用: {oldPath} -> {newPath}");
                        }
                    }
                    
                    EditorUtility.SetDirty(obj);
                }
            }
            
            AssetDatabase.SaveAssets();
        }
    }
}