import tkinter as tk
from tkinter import ttk, filedialog, messagebox
import threading
import subprocess
import os
import json
import webbrowser
from datetime import datetime

class GoDependencyDownloader:
    def __init__(self, root):
        self.root = root
        self.root.title("Go 依赖下载器 - 完整版")
        self.root.geometry("1200x850")
        
        # 下载目录
        self.download_dir = tk.StringVar(value=os.getcwd())
        
        # 搜索变量
        self.search_var = tk.StringVar()
        self.search_var.trace('w', self.filter_dependencies)
        
        # 已安装依赖搜索变量
        self.installed_search_var = tk.StringVar()
        self.installed_search_var.trace('w', self.filter_installed_dependencies)
        
        # 分类变量
        self.category_var = tk.StringVar(value="全部")
        
        # 显示模式：全部依赖/已安装依赖
        self.show_mode = tk.StringVar(value="all")
        
        # 已安装的依赖列表
        self.installed_deps = {}
        self.filtered_installed_deps = {}  # 过滤后的已安装依赖
        
        # 自定义依赖列表
        self.custom_deps_file = "custom_dependencies.json"
        self.custom_dependencies = self.load_custom_dependencies()
        
        # 完整的依赖数据库
        self.all_dependencies = self.load_dependency_database()
        
        # 合并自定义依赖
        self.merge_custom_dependencies()
        
        # 当前显示的依赖
        self.current_deps = []
        self.check_vars = {}
        self.status_vars = {}
        
        self.setup_ui()
        self.load_initial_deps()
        
        # 自动检测当前目录的依赖
        self.detect_installed_dependencies()
        
    def load_custom_dependencies(self):
        """加载用户自定义的依赖"""
        if os.path.exists(self.custom_deps_file):
            try:
                with open(self.custom_deps_file, 'r', encoding='utf-8') as f:
                    return json.load(f)
            except:
                return []
        return []
    
    def save_custom_dependencies(self):
        """保存用户自定义的依赖"""
        try:
            with open(self.custom_deps_file, 'w', encoding='utf-8') as f:
                json.dump(self.custom_dependencies, f, ensure_ascii=False, indent=2)
        except Exception as e:
            print(f"保存自定义依赖失败: {e}")
    
    def merge_custom_dependencies(self):
        """将自定义依赖合并到依赖数据库中"""
        if self.custom_dependencies:
            if "用户自定义" not in self.all_dependencies:
                self.all_dependencies["用户自定义"] = []
            
            existing_names = {dep["name"] for dep in self.all_dependencies["用户自定义"]}
            for custom_dep in self.custom_dependencies:
                if custom_dep["name"] not in existing_names:
                    self.all_dependencies["用户自定义"].append(custom_dep)
    
    def detect_installed_dependencies(self):
        """检测当前目录已安装的依赖"""
        self.installed_deps = {}
        go_mod_path = os.path.join(self.download_dir.get(), "go.mod")
        
        if not os.path.exists(go_mod_path):
            self.status_var.set("未找到 go.mod 文件，无法检测已安装依赖")
            return
        
        try:
            # 方法1：读取 go.mod 文件
            with open(go_mod_path, 'r', encoding='utf-8') as f:
                content = f.read()
                lines = content.split('\n')
                for line in lines:
                    line = line.strip()
                    if line.startswith('require'):
                        if '(' in line:
                            continue
                        else:
                            parts = line.replace('require', '').strip().split()
                            if len(parts) >= 2:
                                dep_name = parts[0]
                                dep_version = parts[1]
                                self.installed_deps[dep_name] = {
                                    'version': dep_version,
                                    'source': 'go.mod'
                                }
                    elif line and not line.startswith('//') and not line.startswith(')'):
                        if 'require' in line:
                            continue
                        parts = line.split()
                        if len(parts) >= 2:
                            dep_name = parts[0]
                            dep_version = parts[1]
                            if not dep_name.startswith('go') and '.' in dep_name:
                                self.installed_deps[dep_name] = {
                                    'version': dep_version,
                                    'source': 'go.mod'
                                }
            
            # 方法2：使用 go list 命令
            self._get_detailed_installed_deps()
            
            self.filtered_installed_deps = self.installed_deps.copy()
            installed_count = len(self.installed_deps)
            self.status_var.set(f"检测到 {installed_count} 个已安装的依赖")
            self.update_installed_tab()
            self.filter_dependencies()
            
        except Exception as e:
            self.status_var.set(f"检测依赖失败: {str(e)}")
    
    def filter_installed_dependencies(self, *args):
        """过滤已安装依赖列表"""
        search_text = self.installed_search_var.get().lower()
        
        if not search_text:
            self.filtered_installed_deps = self.installed_deps.copy()
        else:
            self.filtered_installed_deps = {}
            for dep_name, info in self.installed_deps.items():
                if search_text in dep_name.lower():
                    self.filtered_installed_deps[dep_name] = info
        
        self.update_installed_tab()
    
    def _get_detailed_installed_deps(self):
        """使用 go list 命令获取详细的依赖信息"""
        try:
            original_dir = os.getcwd()
            os.chdir(self.download_dir.get())
            
            cmd = ["go", "list", "-m", "all"]
            result = subprocess.run(cmd, capture_output=True, text=True, timeout=30)
            
            if result.returncode == 0:
                lines = result.stdout.strip().split('\n')
                for line in lines:
                    if line and not line.startswith('go'):
                        parts = line.split()
                        if len(parts) >= 2:
                            dep_name = parts[0]
                            dep_version = parts[1]
                            if dep_name not in self.installed_deps:
                                self.installed_deps[dep_name] = {
                                    'version': dep_version,
                                    'source': 'go list'
                                }
            
            os.chdir(original_dir)
        except:
            pass
    
    def load_dependency_database(self):
        """加载依赖数据库"""
        return {
            "二维码/条码处理": [
                {"name": "github.com/makiuchi-d/gozxing", "version": "latest", "description": "ZXing 的 Go 实现，支持多种条码格式", "stars": "1.2k+", "important": True},
                {"name": "github.com/boombuler/barcode", "version": "latest", "description": "条码生成库，支持 QR Code, DataMatrix, PDF417 等", "stars": "1.8k+", "important": True},
                {"name": "github.com/tuotoo/qrcode", "version": "latest", "description": "QR Code 编解码库", "stars": "400+", "important": True},
                {"name": "github.com/skip2/go-qrcode", "version": "latest", "description": "高性能 QR Code 生成库", "stars": "2.5k+"},
                {"name": "github.com/yeqown/go-qrcode/v2", "version": "latest", "description": "QR Code 生成器，支持 Logo 和自定义样式", "stars": "600+"},
            ],
            "DataMatrix": [
                {"name": "github.com/facette/datamatrix", "version": "latest", "description": "DataMatrix 码生成和读取", "stars": "100+", "important": True},
            ],
            "PDF417": [
                {"name": "github.com/rsc/pdf417", "version": "latest", "description": "PDF417 条码编解码", "stars": "100+", "important": True},
            ],
            "Web框架": [
                {"name": "github.com/gin-gonic/gin", "version": "latest", "description": "高性能 Web 框架", "stars": "75k+"},
                {"name": "github.com/labstack/echo", "version": "latest", "description": "高性能、极简 Web 框架", "stars": "28k+"},
                {"name": "github.com/gofiber/fiber", "version": "latest", "description": "Express 风格的 Web 框架", "stars": "31k+"},
            ],
            "数据库/ORM": [
                {"name": "gorm.io/gorm", "version": "latest", "description": "功能强大的 ORM", "stars": "35k+"},
                {"name": "github.com/go-sql-driver/mysql", "version": "latest", "description": "MySQL 驱动", "stars": "14k+"},
                {"name": "github.com/go-redis/redis/v8", "version": "latest", "description": "Redis 客户端", "stars": "19k+"},
            ],
            "工具/实用": [
                {"name": "github.com/google/uuid", "version": "latest", "description": "UUID 生成", "stars": "5k+"},
                {"name": "github.com/robfig/cron/v3", "version": "latest", "description": "定时任务", "stars": "12k+"},
                {"name": "github.com/spf13/viper", "version": "latest", "description": "配置管理", "stars": "25k+"},
            ],
        }
    
    def setup_ui(self):
        # 使用主框架
        main_frame = ttk.Notebook(self.root)
        main_frame.pack(fill=tk.BOTH, expand=True)
        
        # 创建依赖管理选项卡
        deps_tab = tk.Frame(main_frame)
        main_frame.add(deps_tab, text="依赖管理")
        
        # 创建设置选项卡
        settings_tab = tk.Frame(main_frame)
        main_frame.add(settings_tab, text="设置")
        
        # 创建已安装依赖选项卡
        installed_tab = tk.Frame(main_frame)
        main_frame.add(installed_tab, text="已安装依赖")
        
        self.setup_deps_tab(deps_tab)
        self.setup_settings_tab(settings_tab)
        self.setup_installed_tab(installed_tab)
    
    def setup_deps_tab(self, parent):
        # 顶部控制面板
        control_frame = tk.Frame(parent)
        control_frame.pack(fill=tk.X, padx=10, pady=5)
        
        # 第一行：搜索和操作按钮
        row1 = tk.Frame(control_frame)
        row1.pack(fill=tk.X, pady=2)
        
        tk.Label(row1, text="搜索:").pack(side=tk.LEFT, padx=5)
        search_entry = tk.Entry(row1, textvariable=self.search_var, width=30)
        search_entry.pack(side=tk.LEFT, padx=5)
        
        # 显示模式切换
        tk.Label(row1, text="显示:").pack(side=tk.LEFT, padx=(20,5))
        all_rb = tk.Radiobutton(row1, text="全部依赖", variable=self.show_mode, 
                                value="all", command=self.filter_dependencies)
        all_rb.pack(side=tk.LEFT, padx=2)
        installed_rb = tk.Radiobutton(row1, text="已安装", variable=self.show_mode, 
                                      value="installed", command=self.filter_dependencies)
        installed_rb.pack(side=tk.LEFT, padx=2)
        
        refresh_btn = tk.Button(row1, text="刷新检测", command=self.refresh_installed_deps, width=10)
        refresh_btn.pack(side=tk.LEFT, padx=10)
        
        # 操作按钮
        btn_frame1 = tk.Frame(row1)
        btn_frame1.pack(side=tk.RIGHT, padx=5)
        
        select_all_btn = tk.Button(btn_frame1, text="全选", command=self.select_all, width=8)
        select_all_btn.pack(side=tk.LEFT, padx=2)
        
        deselect_btn = tk.Button(btn_frame1, text="取消全选", command=self.deselect_all, width=8)
        deselect_btn.pack(side=tk.LEFT, padx=2)
        
        download_selected_btn = tk.Button(btn_frame1, text="下载选中", command=self.download_selected,
                                         bg="#4CAF50", fg="white", width=10)
        download_selected_btn.pack(side=tk.LEFT, padx=2)
        
        download_all_btn = tk.Button(btn_frame1, text="全部下载", command=self.download_all,
                                    bg="#2196F3", fg="white", width=10)
        download_all_btn.pack(side=tk.LEFT, padx=2)
        
        # 第二行：添加自定义依赖
        row2 = tk.Frame(control_frame)
        row2.pack(fill=tk.X, pady=5)
        
        tk.Label(row2, text="添加依赖:", font=("Arial", 10, "bold")).pack(side=tk.LEFT, padx=5)
        
        self.custom_dep_entry = tk.Entry(row2, width=50)
        self.custom_dep_entry.pack(side=tk.LEFT, padx=5, fill=tk.X, expand=True)
        self.custom_dep_entry.insert(0, "github.com/username/repo")
        
        add_custom_btn = tk.Button(row2, text="+ 添加", command=self.add_custom_dependency, 
                                   bg="#9C27B0", fg="white", width=10)
        add_custom_btn.pack(side=tk.LEFT, padx=5)
        
        manage_custom_btn = tk.Button(row2, text="管理自定义", command=self.manage_custom_dependencies,
                                     bg="#FF9800", fg="white", width=10)
        manage_custom_btn.pack(side=tk.LEFT, padx=5)
        
        # 第三行：分类选择
        row3 = tk.Frame(control_frame)
        row3.pack(fill=tk.X, pady=5)
        
        tk.Label(row3, text="分类:", font=("Arial", 10, "bold")).pack(side=tk.LEFT, padx=5)
        
        categories = ["全部"] + list(self.all_dependencies.keys())
        self.category_combo = ttk.Combobox(row3, textvariable=self.category_var, 
                                           values=categories, width=20, state="readonly")
        self.category_combo.pack(side=tk.LEFT, padx=5)
        self.category_combo.bind('<<ComboboxSelected>>', lambda e: self.filter_dependencies())
        
        init_btn = tk.Button(row3, text="初始化 go.mod", command=self.init_go_mod, 
                            bg="#FF9800", fg="white", width=12)
        init_btn.pack(side=tk.RIGHT, padx=5)
        
        self.stats_label = tk.Label(row3, text="", fg="gray")
        self.stats_label.pack(side=tk.RIGHT, padx=10)
        
        # 创建主列表框架
        list_frame = tk.Frame(parent)
        list_frame.pack(fill=tk.BOTH, expand=True, padx=10, pady=5)
        
        # 创建 Treeview 并绑定点击事件
        columns = ("选择", "状态", "依赖包", "版本", "描述", "Stars")
        self.tree = ttk.Treeview(list_frame, columns=columns, show="headings", height=20)
        
        # 设置列宽
        self.tree.column("选择", width=60, anchor="center")
        self.tree.column("状态", width=100, anchor="center")
        self.tree.column("依赖包", width=400, anchor="w")
        self.tree.column("版本", width=80, anchor="center")
        self.tree.column("描述", width=450, anchor="w")
        self.tree.column("Stars", width=80, anchor="center")
        
        # 设置列标题
        self.tree.heading("选择", text="选择")
        self.tree.heading("状态", text="状态")
        self.tree.heading("依赖包", text="依赖包")
        self.tree.heading("版本", text="版本")
        self.tree.heading("描述", text="描述")
        self.tree.heading("Stars", text="Stars")
        
        # 绑定点击事件
        self.tree.bind("<ButtonRelease-1>", self.on_tree_click)
        
        # 滚动条
        v_scrollbar = tk.Scrollbar(list_frame, orient="vertical", command=self.tree.yview)
        h_scrollbar = tk.Scrollbar(list_frame, orient="horizontal", command=self.tree.xview)
        self.tree.configure(yscrollcommand=v_scrollbar.set, xscrollcommand=h_scrollbar.set)
        
        self.tree.pack(side=tk.LEFT, fill=tk.BOTH, expand=True)
        v_scrollbar.pack(side=tk.RIGHT, fill=tk.Y)
        h_scrollbar.pack(side=tk.BOTTOM, fill=tk.X)
        
        # 右键菜单
        self.context_menu = tk.Menu(self.root, tearoff=0)
        self.context_menu.add_command(label="复制依赖路径", command=self.copy_dep_path)
        self.context_menu.add_command(label="在浏览器中打开", command=self.open_in_browser)
        self.context_menu.add_separator()
        self.context_menu.add_command(label="更新此依赖", command=self.update_single_dependency)
        self.context_menu.add_command(label="删除此依赖", command=self.remove_single_dependency)
        self.tree.bind("<Button-3>", self.show_context_menu)
        
        # 底部状态栏
        status_frame = tk.Frame(parent)
        status_frame.pack(side=tk.BOTTOM, fill=tk.X)
        
        self.status_var = tk.StringVar(value="就绪")
        status_bar = tk.Label(status_frame, textvariable=self.status_var, bd=1, 
                              relief=tk.SUNKEN, anchor=tk.W)
        status_bar.pack(side=tk.LEFT, fill=tk.X, expand=True)
        
        self.progress = ttk.Progressbar(status_frame, mode='indeterminate', length=200)
        self.progress.pack(side=tk.RIGHT, padx=5)
    
    def setup_installed_tab(self, parent):
        """设置已安装依赖选项卡"""
        # 顶部控制面板
        control_frame = tk.Frame(parent)
        control_frame.pack(fill=tk.X, padx=10, pady=5)
        
        # 第一行：搜索和操作按钮
        row1 = tk.Frame(control_frame)
        row1.pack(fill=tk.X, pady=5)
        
        tk.Label(row1, text="搜索依赖:").pack(side=tk.LEFT, padx=5)
        search_entry = tk.Entry(row1, textvariable=self.installed_search_var, width=40)
        search_entry.pack(side=tk.LEFT, padx=5)
        
        # 操作按钮组
        btn_frame = tk.Frame(row1)
        btn_frame.pack(side=tk.RIGHT, padx=5)
        
        refresh_btn = tk.Button(btn_frame, text="刷新检测", command=self.refresh_installed_deps, 
                                bg="#2196F3", fg="white", width=10)
        refresh_btn.pack(side=tk.LEFT, padx=2)
        
        select_all_installed_btn = tk.Button(btn_frame, text="全选", command=self.select_all_installed, 
                                             bg="#9C27B0", fg="white", width=8)
        select_all_installed_btn.pack(side=tk.LEFT, padx=2)
        
        deselect_all_installed_btn = tk.Button(btn_frame, text="取消全选", command=self.deselect_all_installed, 
                                               width=8)
        deselect_all_installed_btn.pack(side=tk.LEFT, padx=2)
        
        # 第二行：批量操作按钮
        row2 = tk.Frame(control_frame)
        row2.pack(fill=tk.X, pady=5)
        
        update_selected_btn = tk.Button(row2, text="更新选中", command=self.update_selected_dependencies,
                                        bg="#FF9800", fg="white", width=12)
        update_selected_btn.pack(side=tk.LEFT, padx=5)
        
        delete_selected_btn = tk.Button(row2, text="删除选中", command=self.delete_selected_dependencies,
                                        bg="#F44336", fg="white", width=12)
        delete_selected_btn.pack(side=tk.LEFT, padx=5)
        
        update_all_btn = tk.Button(row2, text="更新全部", command=self.update_all_dependencies,
                                   bg="#4CAF50", fg="white", width=12)
        update_all_btn.pack(side=tk.LEFT, padx=5)
        
        delete_all_btn = tk.Button(row2, text="删除全部", command=self.delete_all_dependencies,
                                   bg="#D32F2F", fg="white", width=12)
        delete_all_btn.pack(side=tk.LEFT, padx=5)
        
        # 统计信息
        self.installed_stats_label = tk.Label(row2, text="", fg="gray")
        self.installed_stats_label.pack(side=tk.RIGHT, padx=10)
        
        # 当前目录显示
        tk.Label(row2, text=f"目录: {self.download_dir.get()}", fg="gray").pack(side=tk.RIGHT, padx=10)
        
        # 创建列表框架
        list_frame = tk.Frame(parent)
        list_frame.pack(fill=tk.BOTH, expand=True, padx=10, pady=5)
        
        # 创建 Treeview 支持复选框
        columns = ("选择", "依赖包", "当前版本", "最新版本", "状态")
        self.installed_tree = ttk.Treeview(list_frame, columns=columns, show="headings", height=20)
        
        # 设置列宽
        self.installed_tree.column("选择", width=60, anchor="center")
        self.installed_tree.column("依赖包", width=450, anchor="w")
        self.installed_tree.column("当前版本", width=200, anchor="center")
        self.installed_tree.column("最新版本", width=200, anchor="center")
        self.installed_tree.column("状态", width=150, anchor="center")
        
        # 设置列标题
        self.installed_tree.heading("选择", text="选择")
        self.installed_tree.heading("依赖包", text="依赖包")
        self.installed_tree.heading("当前版本", text="当前版本")
        self.installed_tree.heading("最新版本", text="最新版本")
        self.installed_tree.heading("状态", text="状态")
        
        # 绑定点击事件
        self.installed_tree.bind("<ButtonRelease-1>", self.on_installed_tree_click)
        
        # 滚动条
        v_scrollbar = tk.Scrollbar(list_frame, orient="vertical", command=self.installed_tree.yview)
        h_scrollbar = tk.Scrollbar(list_frame, orient="horizontal", command=self.installed_tree.xview)
        self.installed_tree.configure(yscrollcommand=v_scrollbar.set, xscrollcommand=h_scrollbar.set)
        
        self.installed_tree.pack(side=tk.LEFT, fill=tk.BOTH, expand=True)
        v_scrollbar.pack(side=tk.RIGHT, fill=tk.Y)
        h_scrollbar.pack(side=tk.BOTTOM, fill=tk.X)
        
        # 存储已安装依赖的复选框状态
        self.installed_check_vars = {}
        
        # 右键菜单
        installed_menu = tk.Menu(self.root, tearoff=0)
        installed_menu.add_command(label="更新此依赖", command=self.update_single_dependency)
        installed_menu.add_command(label="删除此依赖", command=self.remove_single_dependency)
        installed_menu.add_separator()
        installed_menu.add_command(label="复制依赖路径", command=self.copy_installed_dep_path)
        self.installed_tree.bind("<Button-3>", lambda e: self.show_installed_context_menu(e, installed_menu))
    
    def on_installed_tree_click(self, event):
        """处理已安装依赖树的点击事件"""
        region = self.installed_tree.identify_region(event.x, event.y)
        if region != "cell":
            return
        
        column = self.installed_tree.identify_column(event.x)
        item = self.installed_tree.identify_row(event.y)
        
        if not item:
            return
        
        # 如果点击的是第一列（选择列）
        if column == "#1":
            if item in self.installed_check_vars:
                current_value = self.installed_check_vars[item].get()
                self.installed_check_vars[item].set(not current_value)
                self.update_installed_tree_display_item(item)
    
    def update_installed_tree_display_item(self, item):
        """更新已安装依赖树的单个项目显示"""
        if item in self.installed_check_vars:
            if self.installed_check_vars[item].get():
                self.installed_tree.set(item, "选择", "✓")
            else:
                self.installed_tree.set(item, "选择", "□")
    
    def select_all_installed(self):
        """全选已安装依赖"""
        for item, var in self.installed_check_vars.items():
            var.set(True)
            self.update_installed_tree_display_item(item)
        self.update_installed_stats()
    
    def deselect_all_installed(self):
        """取消全选已安装依赖"""
        for item, var in self.installed_check_vars.items():
            var.set(False)
            self.update_installed_tree_display_item(item)
        self.update_installed_stats()
    
    def get_selected_installed_deps(self):
        """获取选中的已安装依赖"""
        selected = []
        for item, var in self.installed_check_vars.items():
            if var.get():
                dep_name = self.installed_tree.item(item)['values'][1]
                selected.append(dep_name)
        return selected
    
    def update_selected_dependencies(self):
        """更新选中的依赖"""
        selected = self.get_selected_installed_deps()
        if not selected:
            messagebox.showwarning("警告", "请先选择要更新的依赖")
            return
        
        if messagebox.askyesno("确认", f"确定要更新选中的 {len(selected)} 个依赖吗？"):
            self.download_selected_deps(selected, update_mode=True)
    
    def delete_selected_dependencies(self):
        """删除选中的依赖"""
        selected = self.get_selected_installed_deps()
        if not selected:
            messagebox.showwarning("警告", "请先选择要删除的依赖")
            return
        
        if messagebox.askyesno("确认", f"确定要删除选中的 {len(selected)} 个依赖吗？\n\n注意：这只会从 go.mod 中移除引用，不会删除已下载的代码包。"):
            self.delete_multiple_dependencies(selected)
    
    def delete_all_dependencies(self):
        """删除所有依赖"""
        if not self.filtered_installed_deps:
            messagebox.showwarning("警告", "没有检测到已安装的依赖")
            return
        
        count = len(self.filtered_installed_deps)
        if messagebox.askyesno("警告", f"确定要删除所有 {count} 个依赖吗？\n\n此操作不可撤销！\n注意：这只会从 go.mod 中移除引用，不会删除已下载的代码包。"):
            deps_to_delete = list(self.filtered_installed_deps.keys())
            self.delete_multiple_dependencies(deps_to_delete)
    
    def delete_multiple_dependencies(self, dep_names):
        """批量删除依赖"""
        def delete_worker():
            self.progress.start()
            self.status_var.set(f"正在删除 {len(dep_names)} 个依赖...")
            
            original_dir = os.getcwd()
            success_count = 0
            
            try:
                os.chdir(self.download_dir.get())
                
                for dep_name in dep_names:
                    self.status_var.set(f"正在删除: {dep_name}")
                    
                    try:
                        # 从 go.mod 中删除依赖
                        cmd = ["go", "mod", "edit", "-droprequire", dep_name]
                        result = subprocess.run(cmd, capture_output=True, text=True, timeout=30)
                        
                        if result.returncode == 0:
                            success_count += 1
                        else:
                            print(f"删除 {dep_name} 失败: {result.stderr}")
                            
                    except Exception as e:
                        print(f"删除 {dep_name} 出错: {str(e)}")
                
                # 运行 go mod tidy 清理
                self.status_var.set("正在运行 go mod tidy 清理...")
                subprocess.run(["go", "mod", "tidy"], capture_output=True, timeout=60)
                
                self.status_var.set(f"删除完成，成功 {success_count}/{len(dep_names)} 个依赖")
                messagebox.showinfo("完成", f"删除完成\n\n成功: {success_count}\n失败: {len(dep_names)-success_count}")
                
                # 刷新显示
                self.detect_installed_dependencies()
                self.update_installed_tab()
                self.filter_dependencies()
                
            except Exception as e:
                messagebox.showerror("错误", f"删除出错: {str(e)}")
            finally:
                os.chdir(original_dir)
                self.progress.stop()
        
        threading.Thread(target=delete_worker, daemon=True).start()
    
    def update_installed_tab(self):
        """更新已安装依赖选项卡的显示"""
        # 清空现有显示
        for item in self.installed_tree.get_children():
            self.installed_tree.delete(item)
        
        self.installed_check_vars.clear()
        
        if not self.filtered_installed_deps:
            self.installed_tree.insert("", tk.END, values=("", "未检测到依赖", "", "", "请先初始化 go.mod"))
            self.installed_stats_label.config(text="共 0 个依赖")
            return
        
        # 显示过滤后的依赖
        for dep_name, info in self.filtered_installed_deps.items():
            var = tk.BooleanVar(value=False)
            current_version = info.get('version', 'unknown')
            latest_version = self.get_latest_version(dep_name)
            
            if latest_version and latest_version != current_version:
                status = "可更新"
                tags = ('updateable',)
            else:
                status = "已是最新"
                tags = ('up_to_date',)
            
            item = self.installed_tree.insert("", tk.END, values=(
                "□", dep_name, current_version, latest_version or "查询失败", status
            ), tags=tags)
            
            self.installed_check_vars[item] = var
        
        # 配置标签样式
        self.installed_tree.tag_configure('updateable', background='#FFF3E0')
        self.installed_tree.tag_configure('up_to_date', background='#E8F5E9')
        
        self.update_installed_stats()
    
    def update_installed_stats(self):
        """更新已安装依赖统计信息"""
        total = len(self.filtered_installed_deps)
        selected = len(self.get_selected_installed_deps())
        self.installed_stats_label.config(text=f"共 {total} 个依赖 (已选中 {selected} 个)")
    
    def setup_settings_tab(self, parent):
        """设置选项卡"""
        settings_frame = tk.Frame(parent, padx=20, pady=20)
        settings_frame.pack(fill=tk.BOTH, expand=True)
        
        # 下载目录设置
        dir_frame = tk.LabelFrame(settings_frame, text="下载目录设置", padx=10, pady=10)
        dir_frame.pack(fill=tk.X, pady=10)
        
        tk.Label(dir_frame, text="下载目录:").grid(row=0, column=0, sticky=tk.W, padx=5)
        dir_entry = tk.Entry(dir_frame, textvariable=self.download_dir, width=60)
        dir_entry.grid(row=0, column=1, padx=5)
        tk.Button(dir_frame, text="浏览", command=self.select_directory).grid(row=0, column=2, padx=5)
        tk.Button(dir_frame, text="检测依赖", command=self.refresh_installed_deps, 
                 bg="#4CAF50", fg="white").grid(row=0, column=3, padx=5)
        
        # Go 代理设置
        proxy_frame = tk.LabelFrame(settings_frame, text="Go 代理设置", padx=10, pady=10)
        proxy_frame.pack(fill=tk.X, pady=10)
        
        tk.Label(proxy_frame, text="GOPROXY:").grid(row=0, column=0, sticky=tk.W, padx=5)
        self.proxy_var = tk.StringVar(value="https://goproxy.cn,direct")
        proxy_entry = tk.Entry(proxy_frame, textvariable=self.proxy_var, width=60)
        proxy_entry.grid(row=0, column=1, padx=5)
        tk.Button(proxy_frame, text="设置代理", command=self.set_go_proxy).grid(row=0, column=2, padx=5)
        
        # 提示信息
        info_frame = tk.LabelFrame(settings_frame, text="使用说明", padx=10, pady=10)
        info_frame.pack(fill=tk.BOTH, expand=True, pady=10)
        
        info_text = tk.Text(info_frame, height=10, wrap=tk.WORD)
        info_text.pack(fill=tk.BOTH, expand=True)
        info_text.insert(tk.END, """使用说明：

1. 依赖管理选项卡：
   - 显示所有可用的依赖包
   - 可以切换"全部依赖"和"已安装"视图
   - 点击复选框选择要下载的依赖
   - 右键点击可以更新或删除依赖

2. 已安装依赖选项卡：
   - 显示当前目录已安装的所有依赖
   - 支持搜索功能，快速查找依赖
   - 支持多选、全选、取消全选
   - 可以批量更新或删除选中的依赖
   - 可以一键更新全部或删除全部依赖
   - 显示当前版本和最新版本对比
   - 可更新的依赖会高亮显示

3. 下载目录设置：
   - 选择依赖下载的目标目录
   - 点击"检测依赖"可以扫描当前目录的依赖

4. 添加自定义依赖：
   - 在"添加依赖"输入框中输入依赖路径
   - 格式示例：github.com/gin-gonic/gin

5. 依赖管理：
   - 全选/取消全选：快速选择依赖
   - 下载选中：下载选中的依赖
   - 全部下载：下载所有依赖

注意：使用前请确保已安装 Go 语言环境！""")
        info_text.config(state=tk.DISABLED)
    
    def on_tree_click(self, event):
        """处理树形控件的点击事件"""
        region = self.tree.identify_region(event.x, event.y)
        if region != "cell":
            return
        
        column = self.tree.identify_column(event.x)
        item = self.tree.identify_row(event.y)
        
        if not item:
            return
        
        if column == "#1":
            if item in self.check_vars:
                current_value = self.check_vars[item].get()
                self.check_vars[item].set(not current_value)
                self.update_tree_display_item(item)
    
    def update_tree_display_item(self, item):
        """更新单个项目的显示"""
        if item in self.check_vars:
            if self.check_vars[item].get():
                self.tree.set(item, "选择", "✓")
            else:
                self.tree.set(item, "选择", "□")
        
        if item in self.status_vars:
            self.tree.set(item, "状态", self.status_vars[item].get())
    
    def refresh_installed_deps(self):
        """刷新已安装依赖列表"""
        self.detect_installed_dependencies()
        self.update_installed_tab()
        self.filter_dependencies()
        messagebox.showinfo("完成", "已检测当前目录的依赖")
    
    def get_latest_version(self, dep_name):
        """获取依赖的最新版本"""
        try:
            original_dir = os.getcwd()
            os.chdir(self.download_dir.get())
            
            cmd = ["go", "list", "-m", "-u", dep_name]
            result = subprocess.run(cmd, capture_output=True, text=True, timeout=30)
            
            if result.returncode == 0:
                parts = result.stdout.strip().split()
                if len(parts) >= 3:
                    return parts[2]
                elif len(parts) >= 2:
                    return parts[1]
            
            os.chdir(original_dir)
            return None
        except:
            return None
    
    def update_single_dependency(self):
        """更新单个依赖"""
        selected = None
        if self.installed_tree.selection():
            selected = self.installed_tree.selection()[0]
            dep_name = self.installed_tree.item(selected)['values'][1]
        elif self.tree.selection():
            selected = self.tree.selection()[0]
            dep_name = self.tree.item(selected)['values'][2].replace("⭐ ", "").replace("📦 ", "")
        else:
            messagebox.showwarning("警告", "请先选择一个依赖")
            return
        
        if messagebox.askyesno("确认", f"确定要更新依赖 {dep_name} 吗？"):
            self.download_selected_deps([dep_name], update_mode=True)
    
    def remove_single_dependency(self):
        """删除单个依赖"""
        selected = None
        if self.installed_tree.selection():
            selected = self.installed_tree.selection()[0]
            dep_name = self.installed_tree.item(selected)['values'][1]
        elif self.tree.selection():
            selected = self.tree.selection()[0]
            dep_name = self.tree.item(selected)['values'][2].replace("⭐ ", "").replace("📦 ", "")
        else:
            messagebox.showwarning("警告", "请先选择一个依赖")
            return
        
        if messagebox.askyesno("确认", f"确定要从 go.mod 中删除依赖 {dep_name} 吗？\n\n注意：这不会删除已下载的代码包，只会从 go.mod 中移除引用。"):
            self.delete_multiple_dependencies([dep_name])
    
    def update_all_dependencies(self):
        """更新所有依赖"""
        if not self.filtered_installed_deps:
            messagebox.showwarning("警告", "没有检测到已安装的依赖")
            return
        
        if messagebox.askyesno("确认", f"确定要更新所有 {len(self.filtered_installed_deps)} 个依赖吗？\n\n这可能需要一些时间。"):
            def update_all_worker():
                self.progress.start()
                self.status_var.set("正在更新所有依赖...")
                
                original_dir = os.getcwd()
                try:
                    os.chdir(self.download_dir.get())
                    
                    cmd = ["go", "get", "-u", "./..."]
                    result = subprocess.run(cmd, capture_output=True, text=True, timeout=600)
                    
                    if result.returncode == 0:
                        self.status_var.set("更新完成")
                        messagebox.showinfo("成功", "所有依赖已更新完成")
                    else:
                        error_msg = result.stderr if result.stderr else result.stdout
                        messagebox.showerror("错误", f"更新失败:\n{error_msg}")
                    
                    self.detect_installed_dependencies()
                    self.update_installed_tab()
                    self.filter_dependencies()
                    
                except Exception as e:
                    messagebox.showerror("错误", f"更新出错: {str(e)}")
                finally:
                    os.chdir(original_dir)
                    self.progress.stop()
            
            threading.Thread(target=update_all_worker, daemon=True).start()
    
    def copy_installed_dep_path(self):
        """复制已安装依赖的路径"""
        selected = self.installed_tree.selection()
        if selected:
            dep_name = self.installed_tree.item(selected[0])['values'][1]
            self.root.clipboard_clear()
            self.root.clipboard_append(dep_name)
            self.status_var.set(f"已复制: {dep_name}")
    
    def show_installed_context_menu(self, event, menu):
        """显示已安装依赖的右键菜单"""
        item = self.installed_tree.identify_row(event.y)
        if item:
            self.installed_tree.selection_set(item)
            menu.post(event.x_root, event.y_root)
    
    def filter_dependencies(self, *args):
        """过滤依赖"""
        search_text = self.search_var.get().lower()
        category = self.category_var.get()
        show_mode = self.show_mode.get()
        
        for item in self.tree.get_children():
            self.tree.delete(item)
        
        self.check_vars.clear()
        self.status_vars.clear()
        
        filtered = []
        for dep in self.current_deps:
            if category != "全部" and dep["category"] != category:
                continue
            if search_text and search_text not in dep["name"].lower() and search_text not in dep["description"].lower():
                continue
            
            if show_mode == "installed":
                if dep["name"] not in self.installed_deps:
                    continue
            
            filtered.append(dep)
        
        filtered.sort(key=lambda x: (not x.get("important", False), x.get("custom", False), x["name"]))
        
        for dep in filtered:
            var = tk.BooleanVar(value=False)
            status_var = tk.StringVar(value="待下载")
            
            display_name = dep['name']
            if dep.get("important"):
                display_name = f"⭐ {display_name}"
            if dep.get("custom"):
                display_name = f"📦 {display_name}"
            
            is_installed = dep['name'] in self.installed_deps
            
            item = self.tree.insert("", tk.END, values=(
                "□", status_var.get(), display_name, dep['version'], 
                dep['description'], dep['stars']
            ))
            
            self.check_vars[item] = var
            self.status_vars[item] = status_var
            
            self.tree.set(item, "依赖包", dep['name'])
            
            tags = []
            if dep.get("important"):
                tags.append("important")
            if dep.get("custom"):
                tags.append("custom")
            if is_installed:
                tags.append("installed")
            if tags:
                self.tree.item(item, tags=tuple(tags))
        
        self.tree.tag_configure("important", background="#FFF3E0")
        self.tree.tag_configure("custom", background="#E8F5E9")
        self.tree.tag_configure("installed", background="#C8E6C9")
        
        custom_count = sum(1 for d in filtered if d.get("custom"))
        installed_count = sum(1 for d in filtered if d['name'] in self.installed_deps)
        
        if show_mode == "installed":
            self.stats_label.config(text=f"共 {len(filtered)} 个已安装依赖")
        else:
            self.stats_label.config(text=f"共 {len(filtered)} 个依赖 (已安装: {installed_count}, 自定义: {custom_count})")
    
    def add_custom_dependency(self):
        """添加自定义依赖"""
        dep_path = self.custom_dep_entry.get().strip()
        
        if not dep_path or dep_path == "github.com/username/repo":
            messagebox.showwarning("警告", "请输入有效的依赖路径\n例如: github.com/gin-gonic/gin")
            return
        
        if not (dep_path.startswith("github.com/") or 
                dep_path.startswith("golang.org/") or 
                dep_path.startswith("gopkg.in/") or
                dep_path.startswith("gitlab.com/") or
                "." in dep_path):
            result = messagebox.askyesno("确认", 
                f"依赖路径格式可能不正确: {dep_path}\n\n是否继续添加？")
            if not result:
                return
        
        for category, deps in self.all_dependencies.items():
            for dep in deps:
                if dep["name"] == dep_path:
                    messagebox.showinfo("提示", f"依赖 {dep_path} 已存在")
                    return
        
        dialog = tk.Toplevel(self.root)
        dialog.title("添加自定义依赖")
        dialog.geometry("500x350")
        dialog.transient(self.root)
        dialog.grab_set()
        
        dialog.update_idletasks()
        x = (dialog.winfo_screenwidth() // 2) - (500 // 2)
        y = (dialog.winfo_screenheight() // 2) - (350 // 2)
        dialog.geometry(f"+{x}+{y}")
        
        tk.Label(dialog, text="依赖路径:", font=("Arial", 10, "bold")).pack(pady=(20,5))
        tk.Label(dialog, text=dep_path, fg="blue", font=("Arial", 10)).pack()
        
        tk.Label(dialog, text="版本:", font=("Arial", 10, "bold")).pack(pady=(15,5))
        version_var = tk.StringVar(value="latest")
        version_entry = tk.Entry(dialog, textvariable=version_var, width=30)
        version_entry.pack()
        
        tk.Label(dialog, text="描述:", font=("Arial", 10, "bold")).pack(pady=(15,5))
        desc_var = tk.StringVar(value="用户自定义依赖")
        desc_entry = tk.Entry(dialog, textvariable=desc_var, width=50)
        desc_entry.pack()
        
        tk.Label(dialog, text="分类:", font=("Arial", 10, "bold")).pack(pady=(15,5))
        category_var = tk.StringVar(value="用户自定义")
        categories = ["用户自定义"] + [c for c in self.all_dependencies.keys() if c != "用户自定义"]
        category_combo = ttk.Combobox(dialog, textvariable=category_var, values=categories, width=30)
        category_combo.pack()
        
        def confirm_add():
            new_dep = {
                "name": dep_path,
                "version": version_var.get(),
                "description": desc_var.get(),
                "stars": "用户添加",
                "important": False,
                "custom": True,
                "added_time": datetime.now().strftime("%Y-%m-%d %H:%M:%S")
            }
            
            category = category_var.get()
            if category not in self.all_dependencies:
                self.all_dependencies[category] = []
            
            self.all_dependencies[category].append(new_dep)
            self.custom_dependencies.append(new_dep)
            self.save_custom_dependencies()
            
            categories = ["全部"] + list(self.all_dependencies.keys())
            self.category_combo['values'] = categories
            
            self.load_initial_deps()
            
            self.custom_dep_entry.delete(0, tk.END)
            self.custom_dep_entry.insert(0, "github.com/username/repo")
            
            messagebox.showinfo("成功", f"已添加依赖:\n{dep_path}")
            dialog.destroy()
        
        button_frame = tk.Frame(dialog)
        button_frame.pack(pady=20)
        tk.Button(button_frame, text="确定添加", command=confirm_add, bg="#4CAF50", fg="white", width=12).pack(side=tk.LEFT, padx=10)
        tk.Button(button_frame, text="取消", command=dialog.destroy, width=12).pack(side=tk.LEFT, padx=10)
    
    def manage_custom_dependencies(self):
        """管理自定义依赖"""
        if not self.custom_dependencies:
            messagebox.showinfo("提示", "没有自定义依赖")
            return
        
        dialog = tk.Toplevel(self.root)
        dialog.title("管理自定义依赖")
        dialog.geometry("600x450")
        dialog.transient(self.root)
        
        dialog.update_idletasks()
        x = (dialog.winfo_screenwidth() // 2) - (600 // 2)
        y = (dialog.winfo_screenheight() // 2) - (450 // 2)
        dialog.geometry(f"+{x}+{y}")
        
        tk.Label(dialog, text="自定义依赖列表", font=("Arial", 12, "bold")).pack(pady=10)
        
        list_frame = tk.Frame(dialog)
        list_frame.pack(fill=tk.BOTH, expand=True, padx=10, pady=10)
        
        scrollbar = tk.Scrollbar(list_frame)
        scrollbar.pack(side=tk.RIGHT, fill=tk.Y)
        
        listbox = tk.Listbox(list_frame, yscrollcommand=scrollbar.set, font=("Courier", 10), height=15)
        listbox.pack(side=tk.LEFT, fill=tk.BOTH, expand=True)
        scrollbar.config(command=listbox.yview)
        
        for dep in self.custom_dependencies:
            listbox.insert(tk.END, f"{dep['name']}  |  {dep['description']}")
        
        def delete_selected():
            selection = listbox.curselection()
            if selection:
                idx = selection[0]
                dep_to_delete = self.custom_dependencies[idx]
                
                if messagebox.askyesno("确认", f"确定要删除 {dep_to_delete['name']} 吗？"):
                    self.custom_dependencies.pop(idx)
                    self.save_custom_dependencies()
                    
                    self.all_dependencies = self.load_dependency_database()
                    self.merge_custom_dependencies()
                    
                    categories = ["全部"] + list(self.all_dependencies.keys())
                    self.category_combo['values'] = categories
                    self.load_initial_deps()
                    
                    listbox.delete(idx)
                    messagebox.showinfo("成功", f"已删除依赖: {dep_to_delete['name']}")
                    
                    if not self.custom_dependencies:
                        dialog.destroy()
        
        button_frame = tk.Frame(dialog)
        button_frame.pack(pady=10)
        tk.Button(button_frame, text="删除选中", command=delete_selected, bg="#F44336", fg="white", width=12).pack(side=tk.LEFT, padx=10)
        tk.Button(button_frame, text="关闭", command=dialog.destroy, width=12).pack(side=tk.LEFT, padx=10)
    
    def load_initial_deps(self):
        """加载初始依赖列表"""
        self.current_deps = []
        for category, deps in self.all_dependencies.items():
            for dep in deps:
                self.current_deps.append({
                    "category": category,
                    "name": dep["name"],
                    "version": dep["version"],
                    "description": dep["description"],
                    "stars": dep.get("stars", "N/A"),
                    "important": dep.get("important", False),
                    "custom": dep.get("custom", False)
                })
        self.filter_dependencies()
    
    def show_context_menu(self, event):
        """显示右键菜单"""
        item = self.tree.identify_row(event.y)
        if item:
            self.tree.selection_set(item)
            self.context_menu.post(event.x_root, event.y_root)
    
    def copy_dep_path(self):
        selected = self.tree.selection()
        if selected:
            dep_name = self.tree.item(selected[0])['values'][2].replace("⭐ ", "").replace("📦 ", "")
            self.root.clipboard_clear()
            self.root.clipboard_append(dep_name)
            self.status_var.set(f"已复制: {dep_name}")
    
    def open_in_browser(self):
        selected = self.tree.selection()
        if selected:
            dep_name = self.tree.item(selected[0])['values'][2].replace("⭐ ", "").replace("📦 ", "")
            url = f"https://github.com/{dep_name}"
            webbrowser.open(url)
    
    def select_directory(self):
        directory = filedialog.askdirectory(initialdir=self.download_dir.get())
        if directory:
            self.download_dir.set(directory)
            self.detect_installed_dependencies()
            self.update_installed_tab()
            self.filter_dependencies()
    
    def set_go_proxy(self):
        os.environ['GOPROXY'] = self.proxy_var.get()
        self.status_var.set(f"已设置代理: {self.proxy_var.get()}")
        messagebox.showinfo("成功", f"Go 代理已设置为:\n{self.proxy_var.get()}")
    
    def check_go_installed(self):
        try:
            result = subprocess.run(["go", "version"], capture_output=True, text=True, timeout=5)
            return result.returncode == 0
        except:
            return False
    
    def init_go_mod(self):
        if not self.check_go_installed():
            messagebox.showerror("错误", "未检测到 Go 环境！\n请先安装 Go 语言环境。")
            return
        
        target_dir = self.download_dir.get()
        if not os.path.exists(target_dir):
            try:
                os.makedirs(target_dir)
            except Exception as e:
                messagebox.showerror("错误", f"创建目录失败: {e}")
                return
        
        def init_worker():
            self.progress.start()
            self.status_var.set("正在初始化 go.mod...")
            original_dir = os.getcwd()
            try:
                os.chdir(target_dir)
                module_name = os.path.basename(target_dir) or "myproject"
                cmd = ["go", "mod", "init", module_name]
                result = subprocess.run(cmd, capture_output=True, text=True, timeout=30)
                if result.returncode == 0:
                    self.status_var.set("go.mod 初始化成功")
                    messagebox.showinfo("成功", f"go.mod 初始化成功！\n模块名: {module_name}")
                    self.detect_installed_dependencies()
                    self.update_installed_tab()
                else:
                    messagebox.showerror("错误", f"初始化失败:\n{result.stderr}")
            except Exception as e:
                messagebox.showerror("错误", f"初始化出错: {str(e)}")
            finally:
                os.chdir(original_dir)
                self.progress.stop()
        
        threading.Thread(target=init_worker, daemon=True).start()
    
    def select_all(self):
        for item, var in self.check_vars.items():
            var.set(True)
            self.update_tree_display_item(item)
    
    def deselect_all(self):
        for item, var in self.check_vars.items():
            var.set(False)
            self.update_tree_display_item(item)
    
    def get_selected_deps(self):
        result = []
        for item, var in self.check_vars.items():
            if var.get():
                dep_name = self.tree.item(item)['values'][2].replace("⭐ ", "").replace("📦 ", "")
                result.append(dep_name)
        return result
    
    def download_selected_deps(self, dep_names, update_mode=False):
        """下载选中的依赖"""
        if not dep_names:
            return
        
        def download_worker():
            self.progress.start()
            action = "更新" if update_mode else "下载"
            self.status_var.set(f"正在{action}...")
            
            if self.proxy_var.get():
                os.environ['GOPROXY'] = self.proxy_var.get()
            
            target_dir = self.download_dir.get()
            original_dir = os.getcwd()
            success_count = 0
            total = len(dep_names)
            
            try:
                os.chdir(target_dir)
                
                for dep_name in dep_names:
                    self.status_var.set(f"正在{action}: {dep_name}")
                    
                    # 更新对应项目的状态
                    for item, status_var in self.status_vars.items():
                        if self.tree.item(item)['values'][2].replace("⭐ ", "").replace("📦 ", "") == dep_name:
                            status_var.set(f"{action}中...")
                            self.update_tree_display_item(item)
                            break
                    
                    try:
                        if update_mode:
                            cmd = ["go", "get", "-u", dep_name]
                        else:
                            cmd = ["go", "get", "-u", f"{dep_name}@latest"]
                        
                        result = subprocess.run(cmd, capture_output=True, text=True, timeout=300)
                        
                        if result.returncode == 0:
                            success_count += 1
                            for item, status_var in self.status_vars.items():
                                if self.tree.item(item)['values'][2].replace("⭐ ", "").replace("📦 ", "") == dep_name:
                                    status_var.set("✓ 成功")
                                    self.update_tree_display_item(item)
                                    break
                        else:
                            for item, status_var in self.status_vars.items():
                                if self.tree.item(item)['values'][2].replace("⭐ ", "").replace("📦 ", "") == dep_name:
                                    status_var.set("✗ 失败")
                                    self.update_tree_display_item(item)
                                    break
                            
                    except subprocess.TimeoutExpired:
                        for item, status_var in self.status_vars.items():
                            if self.tree.item(item)['values'][2].replace("⭐ ", "").replace("📦 ", "") == dep_name:
                                status_var.set("✗ 超时")
                                self.update_tree_display_item(item)
                                break
                    except Exception as e:
                        for item, status_var in self.status_vars.items():
                            if self.tree.item(item)['values'][2].replace("⭐ ", "").replace("📦 ", "") == dep_name:
                                status_var.set("✗ 错误")
                                self.update_tree_display_item(item)
                                break
                
            finally:
                os.chdir(original_dir)
                self.progress.stop()
            
            self.status_var.set(f"{action}完成，成功 {success_count}/{total} 个依赖")
            messagebox.showinfo("完成", f"{action}完成\n\n成功: {success_count}\n失败: {total-success_count}")
            
            # 重新检测已安装依赖
            self.detect_installed_dependencies()
            self.update_installed_tab()
            self.filter_dependencies()
        
        threading.Thread(target=download_worker, daemon=True).start()
    
    def download_selected(self):
        selected = self.get_selected_deps()
        if selected:
            self.download_selected_deps(selected)
        else:
            messagebox.showwarning("警告", "没有选中任何依赖")
    
    def download_all(self):
        all_deps = [self.tree.item(item)['values'][2].replace("⭐ ", "").replace("📦 ", "") 
                    for item in self.tree.get_children()]
        if all_deps:
            self.download_selected_deps(all_deps)

if __name__ == "__main__":
    root = tk.Tk()
    app = GoDependencyDownloader(root)
    root.mainloop()