webui.py

#!/usr/bin/env python3
"""
数据质量检测工具 - 简约Web UI界面
基于Gradio构建的简洁图形化界面
"""

import gradio as gr
import os
import json
from pathlib import Path
from typing import List, Dict, Any, Optional
import tempfile
import shutil

from data_quality_checker import DataQualityChecker
from batch_processor import BatchProcessor


class DataQualityWebUI:
    """数据质量检测Web UI界面"""
    
    def __init__(self):
        self.checker = DataQualityChecker("config.yaml")  # 固定使用默认配置
        self.available_directories = self._get_common_directories()
        
    def _get_common_directories(self) -> List[str]:
        """获取常用目录列表"""
        directories = ["."]  # 当前目录
        
        # 检测是否为WSL环境
        is_wsl = 'microsoft' in os.uname().release.lower() if hasattr(os, 'uname') else False
        
        # Windows常见目录
        if os.name == 'nt':  # 原生Windows
            user_home = os.path.expanduser("~")
            windows_dirs = [
                user_home,
                os.path.join(user_home, "Desktop"),
                os.path.join(user_home, "Documents"),
                os.path.join(user_home, "Downloads"),
            ]
            # 添加存在的Windows目录
            for d in windows_dirs:
                if os.path.exists(d):
                    directories.append(d)
            
            # 添加常见驱动器
            for drive in ['C:', 'D:', 'E:', 'F:']:
                if os.path.exists(drive + '\\'):
                    directories.append(drive + '\\')
        elif is_wsl:  # WSL环境
            # WSL中的Windows驱动器挂载在/mnt/下
            for drive in ['c', 'd', 'e', 'f']:
                wsl_drive_path = f'/mnt/{drive}'
                if os.path.exists(wsl_drive_path):
                    directories.append(f'{wsl_drive_path} (Windows {drive.upper()}盘)')
            
            # WSL中的Windows用户目录
            try:
                # 尝试获取Windows用户目录
                windows_user_dirs = [
                    '/mnt/c/Users',
                    '/mnt/d/Users' if os.path.exists('/mnt/d/Users') else None
                ]
                for user_dir in windows_user_dirs:
                    if user_dir and os.path.exists(user_dir):
                        directories.append(f'{user_dir} (Windows用户目录)')
                        
                        # 尝试找到当前用户的目录
                        try:
                            for user_folder in os.listdir(user_dir):
                                user_path = os.path.join(user_dir, user_folder)
                                if os.path.isdir(user_path):
                                    desktop_path = os.path.join(user_path, 'Desktop')
                                    documents_path = os.path.join(user_path, 'Documents')
                                    downloads_path = os.path.join(user_path, 'Downloads')
                                    
                                    if os.path.exists(desktop_path):
                                        directories.append(f'{desktop_path} (Windows桌面)')
                                    if os.path.exists(documents_path):
                                        directories.append(f'{documents_path} (Windows文档)')
                                    if os.path.exists(downloads_path):
                                        directories.append(f'{downloads_path} (Windows下载)')
                        except:
                            pass
            except:
                pass
            
            # Linux/WSL 常见目录
            directories.extend(['/home', '/tmp'])
        else:
            # Linux/Mac 常见目录
            directories.extend(['/home', '/tmp', '/var'])
        
        # 添加一些常见的项目目录
        common_dirs = ["docs", "data", "input", "output", "files", "documents", "test"]
        for dir_name in common_dirs:
            if os.path.exists(dir_name) and os.path.isdir(dir_name):
                directories.append(dir_name)
        
        # 添加当前目录下的所有子目录
        try:
            for item in os.listdir('.'):
                if os.path.isdir(item) and not item.startswith('.') and item not in directories:
                    directories.append(item)
        except:
            pass
        
        # 去除重复并过滤存在的目录
        unique_dirs = []
        for d in directories:
            # 提取实际路径用于存在性检查
            actual_path = d.split(" (Windows")[0] if " (Windows" in d else d
            if d == "." or (os.path.exists(actual_path) and os.path.isdir(actual_path)):
                if d not in unique_dirs:
                    unique_dirs.append(d)
            
        return unique_dirs
    
    def _get_subdirectories(self, parent_dir: str) -> List[str]:
        """获取指定目录下的子目录"""
        if not parent_dir or not os.path.exists(parent_dir) or not os.path.isdir(parent_dir):
            return []
        
        subdirs = []
        try:
            for item in os.listdir(parent_dir):
                item_path = os.path.join(parent_dir, item)
                if os.path.isdir(item_path) and not item.startswith('.'):
                    subdirs.append(item_path)
        except PermissionError:
            pass
        except Exception:
            pass
        
        return sorted(subdirs)
    
    def _browse_directory(self, current_dir: str, action: str) -> List[str]:
        """浏览目录"""
        if action == "refresh" or not current_dir:
            return self._get_common_directories()
        
        if action == "browse_subdirs":
            subdirs = self._get_subdirectories(current_dir)
            # 添加父目录选项
            parent_dir = os.path.dirname(current_dir)
            if parent_dir and parent_dir != current_dir:
                subdirs.insert(0, f"📁 {parent_dir} (上级目录)")
            
            # 添加当前目录选项
            subdirs.insert(0, f"✅ {current_dir} (选择此目录)")
            
            return subdirs
        
        return self._get_common_directories()
    
    def _get_files_in_directory(self, directory: str, pattern: str = "*.txt") -> List[str]:
        """获取目录中的文件列表"""
        if not directory or not os.path.exists(directory):
            return []
        
        try:
            files = []
            dir_path = Path(directory)
            
            # 支持不同的文件模式
            if pattern == "*.txt":
                files = [str(f) for f in dir_path.glob("*.txt")]
            elif pattern == "*.md":
                files = [str(f) for f in dir_path.glob("*.md")]
            elif pattern == "*.docx":
                files = [str(f) for f in dir_path.glob("*.docx")]
            else:
                files = [str(f) for f in dir_path.glob("*.*") if f.is_file()]
            
            return sorted(files)
        except:
            return []
    
    def update_file_list(self, directory: str, pattern: str) -> gr.Dropdown:
        """更新文件列表"""
        actual_dir = self._extract_actual_path(directory)
        files = self._get_files_in_directory(actual_dir, pattern)
        return gr.Dropdown(choices=files, value=None, label="选择文件")
    
    def _create_output_directory(self, base_name: str = "output") -> str:
        """创建输出目录"""
        counter = 1
        output_dir = base_name
        
        while os.path.exists(output_dir):
            output_dir = f"{base_name}_{counter}"
            counter += 1
        
        os.makedirs(output_dir, exist_ok=True)
        return output_dir
    
    def _get_output_directories(self) -> List[str]:
        """获取输出目录选项"""
        dirs = ["(自动创建)"]
        
        # 常见输出目录
        common_output_dirs = ["output", "results", "reports", "processed"]
        dirs.extend(common_output_dirs)
        
        # Windows用户目录
        if os.name == 'nt':
            user_home = os.path.expanduser("~")
            user_dirs = [
                os.path.join(user_home, "Desktop"),
                os.path.join(user_home, "Documents"),
            ]
            for d in user_dirs:
                if os.path.exists(d):
                    dirs.append(d)
        
        # 添加现有的输出目录
        try:
            for item in os.listdir('.'):
                if os.path.isdir(item) and (item.startswith('output') or item.startswith('result') or item.startswith('report')):
                    if item not in dirs:
                        dirs.append(item)
        except:
            pass
        
        return dirs
    
    def _extract_actual_path(self, display_path: str) -> str:
        """从显示路径中提取实际路径"""
        # 处理带有描述性标签的路径
        if " (Windows " in display_path and "盘)" in display_path:
            # 如 "/mnt/c (Windows C盘)" -> "/mnt/c"
            return display_path.split(" (Windows ")[0]
        elif " (Windows" in display_path and ")" in display_path:
            # 如 "/mnt/c/Users (Windows用户目录)" -> "/mnt/c/Users"  
            return display_path.split(" (Windows")[0]
        else:
            return display_path
    
    def handle_directory_browse(self, selected_dir: str) -> tuple:
        """处理目录浏览"""
        if selected_dir.startswith("✅"):
            # 用户选择了这个目录
            actual_dir = selected_dir.replace("✅ ", "").replace(" (选择此目录)", "")
            actual_dir = self._extract_actual_path(actual_dir)
            files = self._get_files_in_directory(actual_dir, "*.txt")
            return gr.Dropdown(choices=files, value=None), actual_dir, gr.Button(visible=False)
        
        elif selected_dir.startswith("📁"):
            # 用户要进入上级目录
            parent_dir = selected_dir.replace("📁 ", "").replace(" (上级目录)", "")
            parent_dir = self._extract_actual_path(parent_dir)
            subdirs = self._browse_directory(parent_dir, "browse_subdirs")
            return gr.Dropdown(choices=[], value=None), parent_dir, gr.Button(visible=True)
        
        else:
            # 用户要浏览子目录
            actual_dir = self._extract_actual_path(selected_dir)
            subdirs = self._browse_directory(actual_dir, "browse_subdirs")
            return gr.Dropdown(choices=[], value=None), actual_dir, gr.Button(visible=True)
    
    def _create_custom_config(self, 
                                truncation_check, completeness_check,
                                traditional_simplified_check, format_consistency_check,
                                duplicate_filter_check,
                                special_chars_check, special_chars_action, special_chars_replacement,
                                bracket_matching_check,
                                emoji_detection_check, emoji_action, emoji_replacement,
                                escape_chars_check, escape_action,
                                abnormal_chars_check, abnormal_action, abnormal_replacement):
        """根据用户选择创建自定义配置"""
        import yaml
        import tempfile
        import os
        
        # 读取默认配置
        with open("config.yaml", 'r', encoding='utf-8') as f:
            config = yaml.safe_load(f)
        
        # 根据用户选择更新配置
        config['text_integrity']['truncation_detection']['enabled'] = truncation_check
        config['text_integrity']['completeness_validation']['enabled'] = completeness_check
        config['text_consistency']['traditional_simplified_mix']['enabled'] = traditional_simplified_check
        config['text_consistency']['chinese_english_format']['enabled'] = format_consistency_check
        config['content_duplication']['duplicate_filter']['enabled'] = duplicate_filter_check
        config['format_validation']['special_characters']['enabled'] = special_chars_check
        config['format_validation']['special_characters']['action'] = special_chars_action
        config['format_validation']['special_characters']['replacement_text'] = special_chars_replacement
        config['format_validation']['json_format_validation']['enabled'] = bracket_matching_check
        config['format_validation']['garbled_characters']['enabled'] = False  # 始终禁用乱码符号过滤
        
        # 更新新增的检测项配置
        config['format_validation']['special_characters']['emoji_detection']['enabled'] = emoji_detection_check
        config['format_validation']['special_characters']['emoji_detection']['action'] = emoji_action
        config['format_validation']['special_characters']['emoji_detection']['replacement_text'] = emoji_replacement
        
        # 特殊符号检测始终启用，使用特殊字符检测的配置
        config['format_validation']['special_characters']['special_symbol_detection']['enabled'] = True
        config['format_validation']['special_characters']['special_symbol_detection']['action'] = special_chars_action
        config['format_validation']['special_characters']['special_symbol_detection']['replacement_text'] = special_chars_replacement
        
        # 转义字符处理配置
        config['format_validation']['special_characters']['escape_characters']['enabled'] = escape_chars_check
        config['format_validation']['special_characters']['escape_characters']['action'] = escape_action
        
        config['format_validation']['special_characters']['abnormal_chars']['enabled'] = abnormal_chars_check
        config['format_validation']['special_characters']['abnormal_chars']['action'] = abnormal_action
        config['format_validation']['special_characters']['abnormal_chars']['replacement_text'] = abnormal_replacement
        
        # 创建临时配置文件
        temp_config = tempfile.NamedTemporaryFile(mode='w', suffix='.yaml', delete=False, encoding='utf-8')
        yaml.dump(config, temp_config, default_flow_style=False, allow_unicode=True)
        temp_config.close()
        
        return temp_config.name

    def _custom_batch_process(self, processor, input_dir, pattern, output_dir, 
                             generate_report, output_format, generate_cleaned):
        """自定义批量处理，支持可选报告生成"""
        import glob
        import os
        from pathlib import Path
        
        # 获取文件列表
        search_pattern = os.path.join(input_dir, "**", pattern) if pattern != "*.*" else os.path.join(input_dir, "**", "*.*")
        file_paths = glob.glob(search_pattern, recursive=True)
        file_paths = [f for f in file_paths if os.path.isfile(f)]
        
        results = {
            "total_files": len(file_paths),
            "processed_files": 0,
            "failed_files": 0,
            "summary": {},
            "details": {}
        }
        
        for file_path in file_paths:
            try:
                # 读取文件内容
                with open(file_path, 'r', encoding='utf-8') as f:
                    text = f.read()
                
                # 执行质量检测
                check_results = processor.checker.check_text_quality(text)
                
                # 保存到结果中
                results["details"][file_path] = {
                    "passed": all(r.passed for r in check_results.values()),
                    "results": {k: {"passed": v.passed, "issues": len(v.issues)} 
                              for k, v in check_results.items()}
                }
                
                # 生成报告文件（如果需要）
                if generate_report and output_dir:
                    file_stem = Path(file_path).stem
                    if output_format == "JSON":
                        report = processor.checker.generate_report(check_results, "json")
                        report_file = os.path.join(output_dir, f"{file_stem}_report.json")
                    elif output_format == "YAML":
                        report = processor.checker.generate_report(check_results, "yaml")
                        report_file = os.path.join(output_dir, f"{file_stem}_report.yaml")
                    else:
                        report = processor.checker.generate_report(check_results, "txt")
                        report_file = os.path.join(output_dir, f"{file_stem}_report.txt")
                    
                    with open(report_file, 'w', encoding='utf-8') as f:
                        f.write(report)
                
                # 生成清洗文件（如果需要）
                if generate_cleaned and output_dir:
                    cleaned_text = text
                    for result in check_results.values():
                        if result.cleaned_text:
                            cleaned_text = result.cleaned_text
                            break
                    
                    if cleaned_text != text:
                        file_stem = Path(file_path).stem
                        file_suffix = Path(file_path).suffix
                        cleaned_file = os.path.join(output_dir, f"{file_stem}_cleaned{file_suffix}")
                        with open(cleaned_file, 'w', encoding='utf-8') as f:
                            f.write(cleaned_text)
                
                results["processed_files"] += 1
                
            except Exception as e:
                results["failed_files"] += 1
                results["details"][file_path] = {"error": str(e)}
        
        # 生成汇总统计
        rule_stats = {}
        for file_details in results["details"].values():
            if "results" in file_details:
                for rule_name, rule_result in file_details["results"].items():
                    if rule_name not in rule_stats:
                        rule_stats[rule_name] = {"total_files": 0, "passed_files": 0}
                    rule_stats[rule_name]["total_files"] += 1
                    if rule_result["passed"]:
                        rule_stats[rule_name]["passed_files"] += 1
        
        results["summary"] = rule_stats
        return results

    def process_single_file(self, input_file, current_dir, generate_report, output_format, output_dir, generate_cleaned,
                          special_chars_check, special_chars_action, special_chars_replacement,
                          bracket_matching_check,
                          emoji_detection_check, emoji_action, emoji_replacement,
                          escape_chars_check, escape_action,
                          abnormal_chars_check, abnormal_action, abnormal_replacement):
        """处理单个文件"""
        try:
            if not input_file or not os.path.exists(input_file):
                return "❌ 请选择有效的输入文件", "", "", ""
            
            # 创建自定义配置
            custom_config_file = self._create_custom_config(
                False, False, False,  # 禁用的规则：truncation_check, completeness_check, traditional_simplified_check
                False, False, special_chars_check, special_chars_action, special_chars_replacement,  # 禁用的规则：format_consistency_check, duplicate_filter_check, 启用special_chars_check
                bracket_matching_check,  # bracket_matching_check
                emoji_detection_check, emoji_action, emoji_replacement,
                escape_chars_check, escape_action,
                abnormal_chars_check, abnormal_action, abnormal_replacement
            )
            
            # 使用自定义配置创建检测器
            custom_checker = DataQualityChecker(custom_config_file)
            
            # 读取文件内容
            with open(input_file, 'r', encoding='utf-8') as f:
                text = f.read()
            
            # 执行检测
            results = custom_checker.check_text_quality(text)
            
            # 生成报告
            if output_format == "JSON":
                report = custom_checker.generate_report(results, "json")
            elif output_format == "YAML":
                report = custom_checker.generate_report(results, "yaml")
            else:
                report = custom_checker.generate_report(results, "txt")
            
            # 处理输出目录和保存报告文件
            report_file = ""
            if generate_report:
                if output_dir == "(自动创建)":
                    output_dir = self._create_output_directory()
                else:
                    os.makedirs(output_dir, exist_ok=True)
                
                # 保存报告文件
                file_stem = Path(input_file).stem
                if output_format == "JSON":
                    report_file = os.path.join(output_dir, f"{file_stem}_report.json")
                elif output_format == "YAML":
                    report_file = os.path.join(output_dir, f"{file_stem}_report.yaml")
                else:
                    report_file = os.path.join(output_dir, f"{file_stem}_report.txt")
                
                with open(report_file, 'w', encoding='utf-8') as f:
                    f.write(report)
            else:
                # 如果不生成报告文件，但需要生成清洗文件时，仍需要输出目录
                if generate_cleaned:
                    if output_dir == "(自动创建)":
                        output_dir = self._create_output_directory()
                    else:
                        os.makedirs(output_dir, exist_ok=True)
            
            # 生成清洗后的文本
            cleaned_text = ""
            cleaned_file = ""
            
            if generate_cleaned:
                # 确保有输出目录
                if not output_dir:
                    output_dir = self._create_output_directory()
                    
                cleaned_text = text
                for result in results.values():
                    if result.cleaned_text:
                        cleaned_text = result.cleaned_text
                        break
                
                if cleaned_text != text:
                    file_stem = Path(input_file).stem  # 确保file_stem被定义
                    cleaned_file = os.path.join(output_dir, f"{file_stem}_cleaned{Path(input_file).suffix}")
                    with open(cleaned_file, 'w', encoding='utf-8') as f:
                        f.write(cleaned_text)
                else:
                    cleaned_text = "文本无需清洗"
            
            # 统计结果
            total_rules = len(results)
            rules_with_issues = sum(1 for r in results.values() if not r.passed)
            
            status_msg = f"✅ 处理完成！\n\n"
            status_msg += f"📊 检测结果:\n"
            status_msg += f"  • 检测规则数: {total_rules}\n"
            status_msg += f"  • 发现问题的规则: {rules_with_issues}\n\n"
            
            if generate_report or generate_cleaned:
                status_msg += f"📁 输出位置:\n"
                if output_dir:
                    status_msg += f"  • 输出目录: {output_dir}\n"
                if report_file:
                    status_msg += f"  • 报告文件: {os.path.basename(report_file)}\n"
                if cleaned_file:
                    status_msg += f"  • 清洗文件: {os.path.basename(cleaned_file)}"
            else:
                status_msg += f"📋 仅显示检测结果，未生成文件"
            
            # 清理临时配置文件
            try:
                os.unlink(custom_config_file)
            except:
                pass
            
            return status_msg, report, cleaned_text, output_dir or ""
            
        except Exception as e:
            # 即使出错也要清理临时文件
            try:
                os.unlink(custom_config_file)
            except:
                pass
            return f"❌ 处理失败: {str(e)}", "", "", ""
    
    def process_batch(
        self,
        current_input_dir: str,
        file_pattern: str,
        generate_report: bool,
        output_format: str,
        output_directory: str,
        generate_cleaned: bool,
        special_chars_check, special_chars_action, special_chars_replacement,
        bracket_matching_check,
        emoji_detection_check, emoji_action, emoji_replacement,
        escape_chars_check, escape_action,
        abnormal_chars_check, abnormal_action, abnormal_replacement
    ) -> tuple:
        """批量处理文件"""
        try:
            # 提取实际目录路径
            actual_input_dir = self._extract_actual_path(current_input_dir)
            
            if not actual_input_dir or not os.path.exists(actual_input_dir):
                return "❌ 请选择有效的输入目录", "", ""
            
            # 创建自定义配置
            custom_config_file = self._create_custom_config(
                False, False, False,  # 禁用的规则：truncation_check, completeness_check, traditional_simplified_check
                False, False, special_chars_check, special_chars_action, special_chars_replacement,  # 禁用的规则：format_consistency_check, duplicate_filter_check, 启用special_chars_check
                bracket_matching_check,  # bracket_matching_check
                emoji_detection_check, emoji_action, emoji_replacement,
                escape_chars_check, escape_action,
                abnormal_chars_check, abnormal_action, abnormal_replacement
            )
            
            # 使用自定义配置创建批量处理器
            processor = BatchProcessor(custom_config_file)
            
            # 处理输出目录
            if generate_report or generate_cleaned:
                if output_directory == "(自动创建)":
                    output_dir = self._create_output_directory("batch_output")
                else:
                    output_dir = output_directory
                    os.makedirs(output_dir, exist_ok=True)
            else:
                output_dir = None
            
            # 获取文件列表
            if file_pattern == "*.txt":
                pattern = "*.txt"
            elif file_pattern == "*.md":
                pattern = "*.md"
            elif file_pattern == "*.docx":
                pattern = "*.docx"
            else:
                pattern = "*.*"
            
            # 手动执行批量处理以支持可选报告生成
            results = self._custom_batch_process(
                processor, actual_input_dir, pattern, output_dir, 
                generate_report, output_format, generate_cleaned
            )
            
            # 生成批量报告摘要
            summary = f"🎯 批量处理完成！\n\n"
            summary += f"📊 处理统计:\n"
            summary += f"  • 总文件数: {results['total_files']}\n"
            summary += f"  • 成功处理: {results['processed_files']}\n"
            summary += f"  • 处理失败: {results['failed_files']}\n\n"
            
            if results['summary']:
                summary += f"📋 质量检测统计:\n"
                for rule_name, stats in results['summary'].items():
                    issue_files = stats['total_files'] - stats['passed_files']
                    summary += f"  • {rule_name}: {issue_files} 个文件检测到问题\n"
            
            if generate_report or generate_cleaned:
                summary += f"\n📁 输出目录: {output_dir}"
                if generate_report:
                    summary += f"\n📄 已生成报告文件 (格式: {output_format})"
                if generate_cleaned:
                    summary += f"\n🧹 已生成清洗文件"
            else:
                summary += f"\n📋 仅显示检测结果，未生成文件"
            
            # 详细报告
            detailed_report = json.dumps(results, ensure_ascii=False, indent=2)
            
            # 清理临时配置文件
            try:
                os.unlink(custom_config_file)
            except:
                pass
            
            return summary, detailed_report, output_dir
            
        except Exception as e:
            # 即使出错也要清理临时文件
            try:
                os.unlink(custom_config_file)
            except:
                pass
            return f"❌ 批量处理失败: {str(e)}", "", ""
    
    def create_interface(self):
        """创建Gradio界面"""
        # 自定义CSS样式
        custom_css = """
        .gradio-container {
            max-width: 1400px !important;
            margin: 0 auto !important;
        }
        .gr-group {
            border-radius: 8px !important;
            border: none !important;
            background: #f8f9fa !important;
            padding: 12px !important;
            margin: 8px 0 !important;
            box-shadow: 0 1px 2px rgba(0, 0, 0, 0.05) !important;
        }
        .gr-row {
            gap: 8px !important;
        }
        .gr-column {
            gap: 8px !important;
        }
        .compact-checkbox {
            margin: 4px 0 !important;
        }
        .compact-dropdown {
            margin: 2px 0 !important;
        }
        .section-header {
            font-size: 16px !important;
            font-weight: 600 !important;
            color: #2c3e50 !important;
            margin: 8px 0 !important;
            padding: 6px 0 !important;
            border-bottom: 2px solid #3498db !important;
        }
        .config-section {
            border-left: 3px solid #3498db !important;
            padding-left: 12px !important;
            margin: 8px 0 !important;
        }
        
        /* 目录选择相关样式美化 */
        .directory-browser {
            background: linear-gradient(145deg, #f0f8ff 0%, #e6f3ff 100%) !important;
            border: none !important;
            border-radius: 12px !important;
            padding: 16px !important;
            box-shadow: 0 1px 3px rgba(74, 144, 226, 0.08) !important;
            margin: 8px 0 !important;
        }
        
        .file-input-section {
            background: linear-gradient(145deg, #fff5f5 0%, #ffe6e6 100%) !important;
            border: none !important;
            border-radius: 12px !important;
            padding: 16px !important;
            box-shadow: 0 1px 3px rgba(255, 107, 107, 0.08) !important;
            margin: 8px 0 !important;
        }
        
        .output-config-section {
            background: linear-gradient(145deg, #f0fff0 0%, #e6ffe6 100%) !important;
            border: none !important;
            border-radius: 12px !important;
            padding: 16px !important;
            box-shadow: 0 1px 3px rgba(82, 196, 26, 0.08) !important;
            margin: 8px 0 !important;
        }
        
        /* 按钮美化 */
        .browse-button {
            background: linear-gradient(45deg, #667eea, #764ba2) !important;
            border: none !important;
            color: white !important;
            font-weight: 600 !important;
            border-radius: 8px !important;
            padding: 8px 16px !important;
            box-shadow: 0 2px 4px rgba(102, 126, 234, 0.2) !important;
        }
        
        .browse-button:hover {
            background: linear-gradient(45deg, #5a6fd8, #6a42a0) !important;
            box-shadow: 0 3px 6px rgba(102, 126, 234, 0.3) !important;
        }
        
        /* 下拉框美化 */
        .directory-dropdown {
            border: 1px solid #e0e6ed !important;
            border-radius: 8px !important;
            background: white !important;
            box-shadow: 0 1px 2px rgba(0, 0, 0, 0.05) !important;
        }
        
        .directory-dropdown:focus {
            border-color: #667eea !important;
            box-shadow: 0 0 0 2px rgba(102, 126, 234, 0.1) !important;
        }
        
        /* 文本框美化 */
        .directory-textbox {
            border: 1px solid #e0e6ed !important;
            border-radius: 8px !important;
            background: white !important;
            font-family: 'Monaco', 'Consolas', monospace !important;
        }
        
        .directory-textbox:focus {
            border-color: #667eea !important;
            box-shadow: 0 0 0 2px rgba(102, 126, 234, 0.1) !important;
        }
        
        /* 图标样式 */
        .icon-text {
            display: inline-flex !important;
            align-items: center !important;
            gap: 6px !important;
        }
        """
        
        with gr.Blocks(title="数据质量检测工具", theme=gr.themes.Soft(), css=custom_css) as iface:
            gr.HTML("""
                <div style="text-align: center; padding: 20px 0; background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); border-radius: 10px; margin-bottom: 20px;">
                    <h1 style="color: white; margin: 0; font-size: 2.5em;">🔍 数据质量检测工具</h1>
                    <p style="color: rgba(255,255,255,0.9); margin: 10px 0 0 0; font-size: 1.1em;">智能文本数据质量检测与清洗平台</p>
                </div>
            """)
            
            with gr.Tabs():
                # 单文件处理标签页
                with gr.TabItem("📄 单文件处理"):
                    with gr.Row():
                        # 左侧：文件选择和输出配置
                        with gr.Column(scale=2):
                            with gr.Group(elem_classes=["file-input-section"]):
                                gr.HTML('<h3 class="section-header icon-text">📁 文件选择</h3>')
                                
                                with gr.Row():
                                    input_dir_dropdown = gr.Dropdown(
                                        choices=self.available_directories,
                                        value=".",
                                        label="📂 浏览目录",
                                        scale=3,
                                        elem_classes=["directory-dropdown"]
                                    )
                                    browse_btn = gr.Button("🔍 浏览", scale=1, size="sm", 
                                                         visible=False, elem_classes=["browse-button"])
                                
                                with gr.Row():
                                    current_input_dir = gr.Textbox(
                                        label="当前目录",
                                        value=".",
                                        interactive=False,
                                        scale=2,
                                        elem_classes=["directory-textbox"]
                                    )
                                    file_pattern_radio = gr.Radio(
                                        choices=["*.txt", "*.md", "*.docx", "*.*"],
                                        value="*.txt",
                                        label="文件类型",
                                        scale=1
                                    )
                                
                                input_file_dropdown = gr.Dropdown(
                                    choices=self._get_files_in_directory(".", "*.txt"),
                                    label="📄 选择文件",
                                    interactive=True,
                                    elem_classes=["directory-dropdown"]
                                )
                            
                            with gr.Group(elem_classes=["output-config-section"]):
                                gr.HTML('<h3 class="section-header icon-text">⚙️ 输出配置</h3>')
                                
                                with gr.Row():
                                    generate_report_check = gr.Checkbox(
                                        label="生成检测报告", 
                                        value=True,
                                        elem_classes=["compact-checkbox"]
                                    )
                                    generate_cleaned_check = gr.Checkbox(
                                        label="生成清洗文件", 
                                        value=True,
                                        elem_classes=["compact-checkbox"]
                                    )
                                
                                with gr.Row():
                                    output_format_radio = gr.Radio(
                                        choices=["json", "txt"],
                                        value="json",
                                        label="报告格式",
                                        scale=1
                                    )
                                
                                with gr.Row():
                                    output_dir_dropdown = gr.Dropdown(
                                        choices=["./results"] + self.available_directories,
                                        value="./results",
                                        label="📁 输出目录",
                                        scale=3,
                                        elem_classes=["directory-dropdown"]
                                    )
                                    output_browse_btn = gr.Button("🔍 浏览", scale=1, size="sm", 
                                                                elem_classes=["browse-button"])
                                
                                with gr.Row():
                                    current_output_dir = gr.Textbox(
                                        label="当前输出目录",
                                        value="./results",
                                        interactive=False,
                                        scale=2,
                                        elem_classes=["directory-textbox"]
                                    )
                                    create_output_dir_btn = gr.Button("📂 创建目录", scale=1, size="sm")
                        
                        # 右侧：检测规则配置
                        with gr.Column(scale=2):
                            with gr.Group():
                                gr.HTML('<h3 class="section-header">�️ 检测规则配置</h3>')
                                
                                # 压缩配置项布局
                                with gr.Accordion("📐 格式规范检测", open=True):
                                    with gr.Row():
                                        special_chars_check = gr.Checkbox(
                                            label="🔤 特殊字符", 
                                            value=True,
                                            elem_classes=["compact-checkbox"]
                                        )
                                        special_chars_action = gr.Dropdown(
                                            choices=["mark", "remove", "replace"],
                                            value="mark",
                                            label="处理方式",
                                            scale=1,
                                            elem_classes=["compact-dropdown"]
                                        )
                                        special_chars_replacement = gr.Textbox(
                                            value="[特殊字符]",
                                            label="替换文本",
                                            scale=1,
                                            visible=False
                                        )
                                    
                                    with gr.Row():
                                        emoji_detection_check = gr.Checkbox(
                                            label="😀 表情符号",
                                            value=True,
                                            elem_classes=["compact-checkbox"]
                                        )
                                        emoji_action = gr.Dropdown(
                                            choices=["mark", "remove", "replace"],
                                            value="mark",
                                            label="处理方式",
                                            scale=1,
                                            elem_classes=["compact-dropdown"]
                                        )
                                        emoji_replacement = gr.Textbox(
                                            value="[表情]",
                                            label="替换文本",
                                            scale=1,
                                            visible=False
                                        )
                                    
                                    with gr.Row():
                                        escape_chars_check = gr.Checkbox(
                                            label="⚡ 转义字符",
                                            value=True,
                                            elem_classes=["compact-checkbox"]
                                        )
                                        escape_action = gr.Dropdown(
                                            choices=["convert", "normalize", "mark"],
                                            value="convert",
                                            label="处理方式",
                                            scale=1,
                                            elem_classes=["compact-dropdown"]
                                        )
                                    
                                    with gr.Row():
                                        abnormal_chars_check = gr.Checkbox(
                                            label="⚠️ 异常字符",
                                            value=True,
                                            elem_classes=["compact-checkbox"]
                                        )
                                        abnormal_action = gr.Dropdown(
                                            choices=["remove", "replace", "mark"],
                                            value="remove",
                                            label="处理方式",
                                            scale=1,
                                            elem_classes=["compact-dropdown"]
                                        )
                                        abnormal_replacement = gr.Textbox(
                                            value="[异常字符]",
                                            label="替换文本",
                                            scale=1,
                                            visible=False
                                        )
                                
                                with gr.Row():
                                    bracket_matching_check = gr.Checkbox(
                                        label="🔧 JSON/JSONL格式验证", 
                                        value=True,
                                        info="验证JSON格式并自动修复常见问题",
                                        elem_classes=["compact-checkbox"]
                                    )
                                    process_single_btn = gr.Button(
                                        "🚀 开始检测", 
                                        variant="primary", 
                                        size="lg",
                                        scale=1
                                    )
                    
                    # 动态显示/隐藏替换文本框的事件处理函数
                    def handle_special_chars_action_change(action):
                        return gr.Textbox(visible=(action == "replace"))
                    
                    def handle_emoji_action_change(action):
                        return gr.Textbox(visible=(action == "replace"))
                    
                    def handle_abnormal_action_change(action):
                        return gr.Textbox(visible=(action == "replace"))
                    
                    def handle_dir_selection(selected_dir, pattern):
                        print(f"[DEBUG] handle_dir_selection called: selected_dir='{selected_dir}', pattern='{pattern}'")  
                        
                        # 增强的None检查，包括空字符串和各种形式的None
                        if (selected_dir is None or 
                            selected_dir == "" or 
                            selected_dir == "None" or
                            str(selected_dir).lower() == "none"):
                            print(f"[DEBUG] No directory selected (empty/None), returning to root")
                            return (
                                gr.Dropdown(choices=self.available_directories, value=None, interactive=True),
                                ".",
                                gr.Dropdown(choices=[], value=None, interactive=True),
                                gr.Button(visible=True)
                            )
                        
                        # 防止处理相同的选择（避免循环）
                        if hasattr(self, '_last_selected_dir') and selected_dir == self._last_selected_dir:
                            print(f"[DEBUG] Same directory as last selection, skipping")
                            return gr.update(), gr.update(), gr.update(), gr.update()
                        
                        # 记录当前选择
                        self._last_selected_dir = selected_dir
                        
                        if selected_dir == "🏠 返回根目录列表":
                            print(f"[DEBUG] Returning to root directory list")
                            self._last_selected_dir = None  # 重置
                            return (
                                gr.Dropdown(choices=self.available_directories, value=None, interactive=True),
                                ".",
                                gr.Dropdown(choices=self._get_files_in_directory(".", pattern), value=None, interactive=True),
                                gr.Button(visible=True)
                            )
                        elif selected_dir.startswith("✅"):
                            print(f"[DEBUG] User confirmed directory selection")
                            actual_dir = selected_dir.replace("✅ ", "").replace(" (选择此目录)", "")
                            actual_dir = self._extract_actual_path(actual_dir)
                            files = self._get_files_in_directory(actual_dir, pattern)
                            current_subdirs = self._browse_directory(actual_dir, "browse_subdirs")
                            print(f"[DEBUG] Confirmed directory: {actual_dir}, files: {len(files)}")
                            return (
                                gr.Dropdown(choices=current_subdirs, value=None, interactive=True),
                                actual_dir,
                                gr.Dropdown(choices=files, value=None, interactive=True),
                                gr.Button(visible=True)
                            )
                        elif selected_dir.startswith("📁"):
                            print(f"[DEBUG] Navigating to parent directory")
                            parent_dir = selected_dir.replace("📁 ", "").replace(" (上级目录)", "")
                            parent_dir = self._extract_actual_path(parent_dir)
                            subdirs = self._browse_directory(parent_dir, "browse_subdirs")
                            print(f"[DEBUG] Parent directory: {parent_dir}, subdirs: {len(subdirs)}")
                            return (
                                gr.Dropdown(choices=subdirs, value=None, interactive=True),
                                parent_dir,
                                gr.Dropdown(choices=[], value=None, interactive=True),
                                gr.Button(visible=True)
                            )
                        else:
                            print(f"[DEBUG] Browsing directory: {selected_dir}")
                            actual_dir = self._extract_actual_path(selected_dir)
                            subdirs = self._browse_directory(actual_dir, "browse_subdirs")
                            files = self._get_files_in_directory(actual_dir, pattern)
                            
                            if selected_dir in self.available_directories:
                                subdirs.insert(0, "🏠 返回根目录列表")
                                print(f"[DEBUG] Added return option for root directory")
                            
                            print(f"[DEBUG] Directory: {actual_dir}, subdirs: {len(subdirs)}, files: {len(files)}")
                            return (
                                gr.Dropdown(choices=subdirs, value=None, interactive=True),
                                actual_dir,
                                gr.Dropdown(choices=files, value=None, interactive=True),
                                gr.Button(visible=True)
                            )
                    
                    def update_files_by_pattern(current_dir, pattern):
                        actual_dir = self._extract_actual_path(current_dir)
                        files = self._get_files_in_directory(actual_dir, pattern)
                        return gr.Dropdown(choices=files, value=None)
                    
                    # 输出目录浏览处理函数
                    def handle_output_browse_click(current_output_dir):
                        if current_output_dir == "(自动创建)" or not current_output_dir:
                            current_dir = "."
                        else:
                            current_dir = current_output_dir
                        # 提取实际路径
                        actual_dir = self._extract_actual_path(current_dir)
                        subdirs = self._browse_directory(actual_dir, "browse_subdirs")
                        return gr.Dropdown(choices=subdirs, label="选择输出目录")
                    
                    def handle_output_dir_selection(selected_dir):
                        print(f"[DEBUG] handle_output_dir_selection called: selected_dir='{selected_dir}'")
                        
                        # 增强的None检查，包括空字符串和各种形式的None
                        if (selected_dir is None or 
                            selected_dir == "" or 
                            selected_dir == "None" or
                            str(selected_dir).lower() == "none"):
                            print(f"[DEBUG] No output directory selected (empty/None), returning unchanged")
                            # 不要返回到根目录，保持当前状态
                            return gr.update(), gr.update()
                        
                        # 防止处理相同的选择（避免循环）
                        if hasattr(self, '_last_selected_output_dir') and selected_dir == self._last_selected_output_dir:
                            print(f"[DEBUG] Same output directory as last selection, skipping")
                            return gr.update(), gr.update()
                        
                        # 记录当前选择
                        self._last_selected_output_dir = selected_dir
                        
                        if selected_dir == "🏠 返回根目录列表":
                            print(f"[DEBUG] Returning to root directory list")
                            self._last_selected_output_dir = None  # 重置
                            self._current_output_browsing_dir = None  # 重置当前浏览目录
                            return (
                                gr.Dropdown(choices=["(自动创建)"] + self.available_directories, value=None, interactive=True),
                                "(自动创建)"
                            )
                        elif selected_dir.startswith("✅"):
                            # 用户确认选择此目录
                            print(f"[DEBUG] User confirmed output directory selection")
                            # 使用当前正在浏览的目录而不是从selected_dir解析
                            if hasattr(self, '_current_output_browsing_dir') and self._current_output_browsing_dir:
                                actual_dir = self._current_output_browsing_dir
                            else:
                                actual_dir = selected_dir.replace("✅ ", "").replace(" (选择此目录)", "")
                                actual_dir = self._extract_actual_path(actual_dir)
                                # 如果解析出来是"."，使用当前工作目录
                                if actual_dir == ".":
                                    actual_dir = os.getcwd()
                            
                            print(f"[DEBUG] Output directory confirmed: {actual_dir}")
                            return (
                                gr.Dropdown(choices=["(自动创建)"] + self.available_directories, value=actual_dir, interactive=True),
                                actual_dir
                            )
                        elif selected_dir.startswith("📁"):
                            # 进入上级目录
                            print(f"[DEBUG] Navigating to parent directory")
                            parent_dir = selected_dir.replace("📁 ", "").replace(" (上级目录)", "")
                            parent_dir = self._extract_actual_path(parent_dir)
                            self._current_output_browsing_dir = parent_dir  # 记录当前浏览目录
                            subdirs = self._browse_directory(parent_dir, "browse_subdirs")
                            print(f"[DEBUG] Parent directory: {parent_dir}, subdirs: {len(subdirs)}")
                            return (
                                gr.Dropdown(choices=subdirs, value=None, interactive=True),
                                parent_dir
                            )
                        else:
                            # 浏览子目录或从根目录选择
                            print(f"[DEBUG] Browsing output directory: {selected_dir}")
                            actual_dir = self._extract_actual_path(selected_dir)
                            self._current_output_browsing_dir = actual_dir  # 记录当前浏览目录
                            subdirs = self._browse_directory(actual_dir, "browse_subdirs")
                            
                            # 如果选择的是根目录列表中的项目，在子目录列表前面添加一个"返回根目录"选项
                            if selected_dir in self.available_directories:
                                subdirs.insert(0, "🏠 返回根目录列表")
                                print(f"[DEBUG] Added return option for root directory")
                            
                            print(f"[DEBUG] Output directory: {actual_dir}, subdirs: {len(subdirs)}")
                            return (
                                gr.Dropdown(choices=subdirs, value=None, interactive=True),
                                actual_dir
                            )
                    
                    # 单文件输出目录浏览处理函数
                    def handle_output_browse_click(current_output_dir):
                        """处理单文件输出目录浏览"""
                        if not current_output_dir:
                            current_dir = "./results"
                        else:
                            current_dir = current_output_dir
                        
                        # 获取当前目录的子目录，使用与输入目录相同的浏览方式
                        actual_dir = self._extract_actual_path(current_dir)
                        subdirs = self._browse_directory(actual_dir, "browse_subdirs")
                        
                        # 添加常用的输出目录选项
                        common_dirs = ["./results", "./output", "./cleaned_data"] + self.available_directories
                        all_dirs = common_dirs + subdirs
                        
                        # 去重并保持顺序
                        unique_dirs = []
                        for d in all_dirs:
                            if d not in unique_dirs:
                                unique_dirs.append(d)
                        
                        return gr.update(choices=unique_dirs, value=None)
                    
                    # 处理输出目录选择
                    def handle_output_dir_select(selected_dir):
                        """处理输出目录选择"""
                        if not selected_dir:
                            return gr.update()
                        
                        if selected_dir == "🏠 返回根目录列表":
                            return gr.update()
                        elif selected_dir == "✅ 使用当前输入的路径":
                            return gr.update(visible=False)
                        elif selected_dir.startswith("📁 C:\\") or selected_dir.startswith("📁 D:\\"):
                            # 处理系统目录
                            path_map = {
                                "📁 C:\\ (C盘根目录)": "C:\\",
                                "📁 C:\\Users (用户目录)": "C:\\Users",
                                "📁 C:\\Users\\Public (公共目录)": "C:\\Users\\Public",
                                "📁 D:\\ (D盘根目录)": "D:\\",
                                "📁 桌面": "C:\\Users\\%USERNAME%\\Desktop",
                                "📁 文档": "C:\\Users\\%USERNAME%\\Documents", 
                                "📁 下载": "C:\\Users\\%USERNAME%\\Downloads"
                            }
                            actual_path = path_map.get(selected_dir, selected_dir.replace("📁 ", ""))
                            return gr.update(value=actual_path, visible=False)
                        elif selected_dir.startswith("📂 "):
                            # 用户选择的子目录
                            actual_path = selected_dir.replace("📂 ", "")
                            return gr.update(value=actual_path, visible=False)
                        else:
                            return gr.update()
                    
                    # 处理输入目录选择
                    def handle_input_dir_selection(selected_dir):
                        """处理输入目录选择"""
                        print(f"[DEBUG] handle_input_dir_selection called: selected_dir='{selected_dir}'")
                        
                        # 增强的None检查
                        if (selected_dir is None or 
                            selected_dir == "" or 
                            selected_dir == "None" or
                            str(selected_dir).lower() == "none"):
                            print(f"[DEBUG] No input directory selected (empty/None), returning unchanged")
                            return gr.update(), gr.update()
                        
                        if selected_dir == "🏠 返回根目录列表":
                            print(f"[DEBUG] Returning to root directory list")
                            return (
                                gr.Dropdown(choices=self.available_directories, value=None, interactive=True),
                                "."
                            )
                        elif selected_dir.startswith("✅"):
                            # 用户确认选择此目录
                            print(f"[DEBUG] User confirmed input directory selection")
                            if hasattr(self, '_current_input_browsing_dir') and self._current_input_browsing_dir:
                                actual_dir = self._current_input_browsing_dir
                            else:
                                actual_dir = selected_dir.replace("✅ ", "").replace(" (选择此目录)", "")
                                actual_dir = self._extract_actual_path(actual_dir)
                                if actual_dir == ".":
                                    actual_dir = os.getcwd()
                            
                            print(f"[DEBUG] Input directory confirmed: {actual_dir}")
                            return (
                                gr.Dropdown(choices=self.available_directories, value=actual_dir, interactive=True),
                                actual_dir
                            )
                        elif selected_dir.startswith("📁"):
                            # 进入上级目录
                            print(f"[DEBUG] Navigating to parent directory")
                            parent_dir = selected_dir.replace("📁 ", "").replace(" (上级目录)", "")
                            parent_dir = self._extract_actual_path(parent_dir)
                            self._current_input_browsing_dir = parent_dir
                            subdirs = self._browse_directory(parent_dir, "browse_subdirs")
                            print(f"[DEBUG] Parent directory: {parent_dir}, subdirs: {len(subdirs)}")
                            return (
                                gr.Dropdown(choices=subdirs, value=None, interactive=True),
                                parent_dir
                            )
                        else:
                            # 浏览子目录或从根目录选择
                            print(f"[DEBUG] Browsing input directory: {selected_dir}")
                            actual_dir = self._extract_actual_path(selected_dir)
                            self._current_input_browsing_dir = actual_dir
                            subdirs = self._browse_directory(actual_dir, "browse_subdirs")
                            
                            # 如果选择的是根目录列表中的项目，在子目录列表前面添加一个"返回根目录"选项
                            if selected_dir in self.available_directories:
                                subdirs.insert(0, "🏠 返回根目录列表")
                                print(f"[DEBUG] Added return option for root directory")
                            
                            print(f"[DEBUG] Input directory: {actual_dir}, subdirs: {len(subdirs)}")
                            return (
                                gr.Dropdown(choices=subdirs, value=None, interactive=True),
                                actual_dir
                            )
                    
                    # 输入目录浏览处理函数
                    def handle_browse_click(current_input_dir):
                        if not current_input_dir:
                            current_dir = "."
                        else:
                            current_dir = current_input_dir
                        # 提取实际路径
                        actual_dir = self._extract_actual_path(current_dir)
                        subdirs = self._browse_directory(actual_dir, "browse_subdirs")
                        return gr.Dropdown(choices=subdirs, label="选择输入目录")
                    
                    # 文件预览相关函数
                    def refresh_file_list(output_dir):
                        """刷新文件列表，获取输出目录中的所有文件"""
                        if not output_dir or not os.path.exists(output_dir):
                            return gr.update(choices=[], value=None)
                        
                        files = []
                        try:
                            for root, dirs, filenames in os.walk(output_dir):
                                for filename in filenames:
                                    if filename.endswith(('.txt', '.json', '.md', '.docx')):
                                        file_path = os.path.join(root, filename)
                                        rel_path = os.path.relpath(file_path, output_dir)
                                        # 添加文件类型图标
                                        if filename.endswith('.json'):
                                            display_name = f"📄 {rel_path}"
                                        elif filename.endswith('.txt'):
                                            display_name = f"📝 {rel_path}"
                                        elif filename.endswith('.md'):
                                            display_name = f"📋 {rel_path}"
                                        elif filename.endswith('.docx'):
                                            display_name = f"📘 {rel_path}"
                                        else:
                                            display_name = f"📄 {rel_path}"
                                        files.append((display_name, file_path))
                        except Exception as e:
                            print(f"Error reading files: {e}")
                            return gr.update(choices=[], value=None)
                        
                        # 按文件类型和名称排序
                        files.sort(key=lambda x: (x[1].split('.')[-1], x[0]))
                        choices = [display for display, _ in files]
                        
                        return gr.update(choices=choices, value=None)
                    
                    def preview_file(selected_file, output_dir):
                        """预览选中的文件内容"""
                        if not selected_file or not output_dir:
                            return "请选择一个文件进行预览..."
                        
                        # 从显示名称中提取实际文件名
                        actual_filename = selected_file.split(' ', 1)[1] if ' ' in selected_file else selected_file
                        file_path = os.path.join(output_dir, actual_filename)
                        
                        if not os.path.exists(file_path):
                            return f"❌ 文件不存在: {file_path}"
                        
                        try:
                            # 限制预览文件大小
                            file_size = os.path.getsize(file_path)
                            if file_size > 1024 * 1024:  # 1MB
                                return f"⚠️ 文件过大 ({file_size / 1024 / 1024:.1f}MB)，请直接打开文件查看"
                            
                            with open(file_path, 'r', encoding='utf-8') as f:
                                content = f.read()
                                
                            # 如果是JSON文件，尝试格式化显示
                            if file_path.endswith('.json'):
                                try:
                                    import json
                                    data = json.loads(content)
                                    content = json.dumps(data, indent=2, ensure_ascii=False)
                                except:
                                    pass  # 如果不是有效JSON，就显示原始内容
                            
                            # 限制显示长度
                            if len(content) > 10000:
                                content = content[:10000] + "\n\n... (内容已截断，完整内容请查看文件)"
                            
                            return f"📁 {file_path}\n📊 大小: {file_size} 字节\n\n{content}"
                            
                        except Exception as e:
                            return f"❌ 读取文件失败: {str(e)}"
                    
                    # 绑定事件 - 使用更精确的事件绑定避免循环触发
                    browse_btn.click(
                        handle_browse_click,
                        inputs=[current_input_dir],
                        outputs=[input_dir_dropdown]
                    )
                    
                    # 使用select事件而不是change事件，只在用户主动选择时触发
                    input_dir_dropdown.select(
                        handle_dir_selection,
                        inputs=[input_dir_dropdown, file_pattern_radio],
                        outputs=[input_dir_dropdown, current_input_dir, input_file_dropdown, browse_btn]
                    )
                    
                    file_pattern_radio.change(
                        update_files_by_pattern,
                        inputs=[current_input_dir, file_pattern_radio],
                        outputs=[input_file_dropdown]
                    )
                    
                    # 输出目录浏览事件
                    output_browse_btn.click(
                        handle_output_browse_click,
                        inputs=[current_output_dir],
                        outputs=[output_dir_dropdown]
                    )
                    
                    output_dir_dropdown.change(
                        handle_output_dir_selection,
                        inputs=[output_dir_dropdown],
                        outputs=[output_dir_dropdown, current_output_dir]
                    )
                    
                    # 新增检测项配置事件绑定
                    special_chars_action.change(
                        handle_special_chars_action_change,
                        inputs=[special_chars_action],
                        outputs=[special_chars_replacement]
                    )
                    
                    emoji_action.change(
                        handle_emoji_action_change,
                        inputs=[emoji_action],
                        outputs=[emoji_replacement]
                    )
                    
                    abnormal_action.change(
                        handle_abnormal_action_change,
                        inputs=[abnormal_action],
                        outputs=[abnormal_replacement]
                    )
                    
                    # 单文件处理结果
                    with gr.Group():
                        gr.HTML('<h3 class="section-header">📊 处理结果</h3>')
                        with gr.Tabs():
                            with gr.TabItem("📋 状态"):
                                single_status_text = gr.Textbox(
                                    label="处理状态", 
                                    lines=8, 
                                    interactive=False,
                                    show_label=False
                                )
                                single_output_dir_text = gr.Textbox(
                                    label="📁 输出目录", 
                                    interactive=False,
                                    show_label=True
                                )
                            
                            with gr.TabItem("📈 检测报告"):
                                single_report_text = gr.Textbox(
                                    label="质量检测报告", 
                                    lines=15, 
                                    interactive=False,
                                    show_label=False
                                )
                            
                            with gr.TabItem("✨ 清洗文本"):
                                single_cleaned_text = gr.Textbox(
                                    label="清洗后的文本", 
                                    lines=15, 
                                    interactive=False,
                                    show_label=False
                                )
                    
                    # 处理按钮事件
                    process_single_btn.click(
                        self.process_single_file,
                        inputs=[
                            input_file_dropdown, current_input_dir, generate_report_check, output_format_radio, 
                            current_output_dir, generate_cleaned_check,
                            special_chars_check, special_chars_action, special_chars_replacement,
                            bracket_matching_check,
                            emoji_detection_check, emoji_action, emoji_replacement,
                            escape_chars_check, escape_action,
                            abnormal_chars_check, abnormal_action, abnormal_replacement
                        ],
                        outputs=[single_status_text, single_report_text, single_cleaned_text, single_output_dir_text]
                    )
                
                # 批量处理标签页
                with gr.TabItem("📦 批量处理"):
                    with gr.Row():
                        # 左侧：目录选择和输出配置
                        with gr.Column(scale=2):
                            with gr.Group(elem_classes=["directory-browser"]):
                                gr.HTML('<h3 class="section-header icon-text">📁 目录选择</h3>')
                                
                                with gr.Row():
                                    batch_input_dir_dropdown = gr.Dropdown(
                                        choices=self.available_directories,
                                        value=".",
                                        label="📂 浏览目录",
                                        scale=3,
                                        elem_classes=["directory-dropdown"]
                                    )
                                    batch_browse_btn = gr.Button("🔍 浏览", scale=1, size="sm", 
                                                               visible=True, elem_classes=["browse-button"])
                                
                                with gr.Row():
                                    batch_current_input_dir = gr.Textbox(
                                        label="当前目录",
                                        value=".",
                                        interactive=False,
                                        scale=2,
                                        elem_classes=["directory-textbox"]
                                    )
                                    batch_file_pattern_radio = gr.Radio(
                                        choices=["*.txt", "*.md", "*.docx", "*.*"],
                                        value="*.txt",
                                        label="文件类型",
                                        scale=1
                                    )
                            
                            with gr.Group(elem_classes=["output-config-section"]):
                                gr.HTML('<h3 class="section-header icon-text">⚙️ 输出配置</h3>')
                                
                                with gr.Row():
                                    batch_generate_report_check = gr.Checkbox(
                                        label="生成检测报告", 
                                        value=True,
                                        elem_classes=["compact-checkbox"]
                                    )
                                    batch_generate_cleaned_check = gr.Checkbox(
                                        label="生成清洗文件", 
                                        value=True,
                                        elem_classes=["compact-checkbox"]
                                    )
                                
                                with gr.Row():
                                    batch_output_format_radio = gr.Radio(
                                        choices=["json", "txt"],
                                        value="json",
                                        label="报告格式",
                                        scale=1
                                    )
                                
                                with gr.Row():
                                    batch_output_dir_dropdown = gr.Dropdown(
                                        choices=["./results"] + self.available_directories,
                                        value="./results",
                                        label="📁 输出目录",
                                        scale=3,
                                        elem_classes=["directory-dropdown"]
                                    )
                                    batch_output_browse_btn = gr.Button("🔍 浏览", scale=1, size="sm", 
                                                                      elem_classes=["browse-button"])
                                
                                with gr.Row():
                                    batch_current_output_dir = gr.Textbox(
                                        label="当前输出目录",
                                        value="./results",
                                        interactive=False,
                                        scale=2,
                                        elem_classes=["directory-textbox"]
                                    )
                                    batch_create_output_dir_btn = gr.Button("📂 创建目录", scale=1, size="sm", 
                                                                           elem_classes=["browse-button"])
                        
                        # 右侧：检测规则配置
                        with gr.Column(scale=2):
                            with gr.Group():
                                gr.HTML('<h3 class="section-header">🛠️ 检测规则配置</h3>')
                                
                                with gr.Accordion("📐 格式规范检测", open=True):
                                    with gr.Row():
                                        batch_special_chars_check = gr.Checkbox(
                                            label="🔤 特殊字符",
                                            value=True,
                                            elem_classes=["compact-checkbox"]
                                        )
                                        batch_special_chars_action = gr.Dropdown(
                                            choices=["mark", "remove", "replace"],
                                            value="mark",
                                            label="处理方式",
                                            scale=1,
                                            elem_classes=["compact-dropdown"]
                                        )
                                        batch_special_chars_replacement = gr.Textbox(
                                            value="[特殊字符]",
                                            label="替换文本",
                                            scale=1,
                                            visible=False
                                        )
                                    
                                    with gr.Row():
                                        batch_emoji_detection_check = gr.Checkbox(
                                            label="😀 表情符号",
                                            value=True,
                                            elem_classes=["compact-checkbox"]
                                        )
                                        batch_emoji_action = gr.Dropdown(
                                            choices=["mark", "remove", "replace"],
                                            value="mark",
                                            label="处理方式",
                                            scale=1,
                                            elem_classes=["compact-dropdown"]
                                        )
                                        batch_emoji_replacement = gr.Textbox(
                                            value="[表情]",
                                            label="替换文本",
                                            scale=1,
                                            visible=False
                                        )
                                    
                                    with gr.Row():
                                        batch_escape_chars_check = gr.Checkbox(
                                            label="⚡ 转义字符",
                                            value=True,
                                            elem_classes=["compact-checkbox"]
                                        )
                                        batch_escape_action = gr.Dropdown(
                                            choices=["convert", "normalize", "mark"],
                                            value="convert",
                                            label="处理方式",
                                            scale=1,
                                            elem_classes=["compact-dropdown"]
                                        )
                                    
                                    with gr.Row():
                                        batch_abnormal_chars_check = gr.Checkbox(
                                            label="⚠️ 异常字符",
                                            value=True,
                                            elem_classes=["compact-checkbox"]
                                        )
                                        batch_abnormal_action = gr.Dropdown(
                                            choices=["remove", "replace", "mark"],
                                            value="remove",
                                            label="处理方式",
                                            scale=1,
                                            elem_classes=["compact-dropdown"]
                                        )
                                        batch_abnormal_replacement = gr.Textbox(
                                            value="[异常字符]",
                                            label="替换文本",
                                            scale=1,
                                            visible=False
                                        )
                                
                                with gr.Row():
                                    batch_bracket_matching_check = gr.Checkbox(
                                        label="🔧 JSON/JSONL格式验证", 
                                        value=True,
                                        elem_classes=["compact-checkbox"]
                                    )
                                    process_batch_btn = gr.Button(
                                        "🚀 批量检测", 
                                        variant="primary", 
                                        size="lg",
                                        scale=1
                                    )
                    
                    # 批量处理结果
                    with gr.Group():
                        gr.HTML('<h3 class="section-header">📊 批量处理结果</h3>')
                        with gr.Tabs():
                            with gr.TabItem("📋 摘要"):
                                with gr.Row():
                                    batch_summary_text = gr.Textbox(
                                        label="处理摘要", 
                                        lines=12, 
                                        interactive=False,
                                        show_label=False,
                                        scale=2
                                    )
                                    batch_output_dir_text = gr.Textbox(
                                        label="📁 输出目录", 
                                        interactive=False,
                                        scale=1
                                    )
                            
                            with gr.TabItem("📄 详细报告"):
                                batch_detailed_text = gr.Textbox(
                                    label="详细报告 (JSON)", 
                                    lines=15, 
                                    interactive=False,
                                    show_label=False
                                )
                            
                            with gr.TabItem("👁️ 文件预览"):
                                with gr.Row():
                                    with gr.Column(scale=1):
                                        batch_file_list = gr.Dropdown(
                                            label="📂 选择要预览的文件",
                                            choices=[],
                                            interactive=True,
                                            elem_classes=["directory-dropdown"]
                                        )
                                        batch_preview_refresh_btn = gr.Button(
                                            "🔄 刷新文件列表", 
                                            size="sm",
                                            elem_classes=["browse-button"]
                                        )
                                    
                                    with gr.Column(scale=3):
                                        batch_file_preview = gr.Textbox(
                                            label="文件内容预览",
                                            lines=20,
                                            interactive=False,
                                            show_label=False,
                                            placeholder="请选择一个文件进行预览...",
                                            elem_classes=["directory-textbox"]
                                        )
                    
                    # 动态显示/隐藏替换文本框的事件处理函数
                    
                    # 批量处理输入目录浏览事件
                    batch_browse_btn.click(
                        handle_browse_click,
                        inputs=[batch_current_input_dir],
                        outputs=[batch_input_dir_dropdown]
                    )
                    
                    batch_input_dir_dropdown.change(
                        handle_input_dir_selection,
                        inputs=[batch_input_dir_dropdown],
                        outputs=[batch_input_dir_dropdown, batch_current_input_dir]
                    )
                    
                    # 批量处理输出目录浏览事件
                    batch_output_browse_btn.click(
                        handle_output_browse_click,
                        inputs=[batch_current_output_dir],
                        outputs=[batch_output_dir_dropdown]
                    )
                    
                    batch_output_dir_dropdown.change(
                        handle_output_dir_selection,
                        inputs=[batch_output_dir_dropdown],
                        outputs=[batch_output_dir_dropdown, batch_current_output_dir]
                    )
                    
                    # 文件预览事件绑定
                    batch_preview_refresh_btn.click(
                        refresh_file_list,
                        inputs=[batch_current_output_dir],
                        outputs=[batch_file_list]
                    )
                    
                    batch_file_list.change(
                        preview_file,
                        inputs=[batch_file_list, batch_current_output_dir],
                        outputs=[batch_file_preview]
                    )
                    
                    # 批量处理按钮事件
                    def update_preview_after_batch(*args):
                        """批量处理完成后自动刷新文件列表"""
                        result = self.process_batch(*args)
                        # 自动刷新文件列表
                        if len(result) >= 3 and result[2]:  # 如果有输出目录
                            output_dir = result[2]
                            try:
                                files = []
                                if os.path.exists(output_dir):
                                    for root, dirs, filenames in os.walk(output_dir):
                                        for filename in filenames:
                                            if filename.endswith(('.txt', '.json', '.md', '.docx')):
                                                file_path = os.path.join(root, filename)
                                                rel_path = os.path.relpath(file_path, output_dir)
                                                if filename.endswith('.json'):
                                                    display_name = f"📄 {rel_path}"
                                                elif filename.endswith('.txt'):
                                                    display_name = f"📝 {rel_path}"
                                                elif filename.endswith('.md'):
                                                    display_name = f"📋 {rel_path}"
                                                elif filename.endswith('.docx'):
                                                    display_name = f"📘 {rel_path}"
                                                else:
                                                    display_name = f"📄 {rel_path}"
                                                files.append((display_name, file_path))
                                    files.sort(key=lambda x: (x[1].split('.')[-1], x[0]))
                                    choices = [display for display, _ in files]
                                else:
                                    choices = []
                                return result + (gr.update(choices=choices, value=None),)
                            except:
                                return result + (gr.update(choices=[], value=None),)
                        return result + (gr.update(choices=[], value=None),)
                    
                    process_batch_btn.click(
                        update_preview_after_batch,
                        inputs=[
                            batch_current_input_dir, batch_file_pattern_radio,
                            batch_generate_report_check, batch_output_format_radio, batch_current_output_dir,
                            batch_generate_cleaned_check,
                            batch_special_chars_check, batch_special_chars_action, batch_special_chars_replacement,
                            batch_bracket_matching_check,
                            batch_emoji_detection_check, batch_emoji_action, batch_emoji_replacement,
                            batch_escape_chars_check, batch_escape_action,
                            batch_abnormal_chars_check, batch_abnormal_action, batch_abnormal_replacement
                        ],
                        outputs=[batch_summary_text, batch_detailed_text, batch_output_dir_text, batch_file_list]
                    )
                
                # 帮助标签页
                with gr.TabItem("📖 使用帮助"):
                    with gr.Row():
                        with gr.Column():
                            with gr.Group():
                                gr.HTML('<h3 class="section-header">🎯 功能概述</h3>')
                                gr.HTML("""
                                <div style="background: linear-gradient(135deg, #f5f7fa 0%, #c3cfe2 100%); padding: 15px; border-radius: 8px; margin: 10px 0;">
                                    <h4 style="color: #2c3e50; margin-top: 0;">📋 当前启用的检测规则</h4>
                                    <ul style="color: #34495e;">
                                        <li><strong>🔤 特殊字符检测</strong> - 表情符号、特殊符号、转义字符、异常字符</li>
                                        <li><strong>🔧 JSON/JSONL格式验证</strong> - 验证格式完整性，自动修复常见问题</li>
                                    </ul>
                                </div>
                                """)
                        
                        with gr.Column():
                            with gr.Group():
                                gr.HTML('<h3 class="section-header">📝 使用步骤</h3>')
                                gr.HTML("""
                                <div style="background: linear-gradient(135deg, #ffecd2 0%, #fcb69f 100%); padding: 15px; border-radius: 8px; margin: 10px 0;">
                                    <h4 style="color: #2c3e50; margin-top: 0;">📄 单文件处理</h4>
                                    <ol style="color: #34495e;">
                                        <li>📂 选择目录 → 📄 选择文件</li>
                                        <li>⚙️ 配置检测规则和处理方式</li>
                                        <li>🚀 点击"开始检测"按钮</li>
                                        <li>📊 查看结果：状态、报告、清洗文本</li>
                                    </ol>
                                    
                                    <h4 style="color: #2c3e50;">📦 批量处理</h4>
                                    <ol style="color: #34495e;">
                                        <li>📁 选择包含多个文件的目录</li>
                                        <li>🎯 选择文件类型 (*.txt, *.md, *.docx, *.*)</li>
                                        <li>⚙️ 配置检测规则</li>
                                        <li>🚀 点击"批量检测"按钮</li>
                                    </ol>
                                </div>
                                """)
                    
                    with gr.Row():
                        with gr.Column():
                            with gr.Group():
                                gr.HTML('<h3 class="section-header">🎛️ 处理方式说明</h3>')
                                gr.HTML("""
                                <div style="background: linear-gradient(135deg, #a8edea 0%, #fed6e3 100%); padding: 15px; border-radius: 8px; margin: 10px 0;">
                                    <ul style="color: #34495e;">
                                        <li><strong>🏷️ mark (标记)</strong> - 仅标注问题，不修改原文</li>
                                        <li><strong>🗑️ remove (移除)</strong> - 直接删除有问题的字符</li>
                                        <li><strong>🔄 replace (替换)</strong> - 用指定文本替换</li>
                                        <li><strong>⚡ convert (转换)</strong> - 转义字符转为实际字符</li>
                                        <li><strong>📏 normalize (标准化)</strong> - 统一格式</li>
                                    </ul>
                                </div>
                                """)
                        
                        with gr.Column():
                            with gr.Group():
                                gr.HTML('<h3 class="section-header">💡 提示</h3>')
                                gr.HTML("""
                                <div style="background: linear-gradient(135deg, #d299c2 0%, #fef9d7 100%); padding: 15px; border-radius: 8px; margin: 10px 0;">
                                    <ul style="color: #34495e;">
                                        <li>📁 支持 WSL 环境下的目录浏览</li>
                                        <li>🔄 自动检测和修复 JSON 格式问题</li>
                                        <li>📊 生成详细的质量检测报告</li>
                                        <li>✨ 提供清洗后的文本预览</li>
                                        <li>💾 结果自动保存到指定目录</li>
                                    </ul>
                                </div>
                                """)
                                
                    gr.HTML("""
                    <div style="text-align: center; padding: 20px; background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); border-radius: 10px; margin-top: 20px;">
                        <p style="color: white; margin: 0; font-size: 1.1em;">🎉 享受高效的数据质量检测体验！</p>
                    </div>
                    """)
        
        return iface


def main():
    """启动Web UI"""
    ui = DataQualityWebUI()
    interface = ui.create_interface()
    
    # 启动界面
    interface.launch(
        server_name="127.0.0.1",  # 本地访问
        server_port=7861,         # 端口号
        share=False,              # 不创建公共链接
        debug=False,              # 调试模式
        show_error=True           # 显示错误信息
    )


if __name__ == "__main__":
    main()