# 文件操作和系統(tǒng)交互
pip install pathlib2
pip install shutil
pip install os-sys

# 文件類型檢測
pip install python-magic
pip install filetype

# 壓縮和備份
pip install pyzipper
pip install rarfile

# 圖像處理（用于圖片文件）
pip install Pillow

# 日期處理
pip install python-dateutil

# 進度顯示
pip install tqdm

# 配置文件處理
pip install pyyaml

# 導入所需庫
import os
import shutil
import re
import hashlib
from pathlib import Path
from datetime import datetime, timedelta
import time
from typing import List, Dict, Optional, Tuple, Callable
import logging
from dataclasses import dataclass
from enum import Enum
import json
import yaml
from tqdm import tqdm
import zipfile
import filetype  # 用于準確檢測文件類型

# 嘗試導入可選依賴
try:
    from PIL import Image, ExifTags
    PIL_AVAILABLE = True
except ImportError:
    PIL_AVAILABLE = False

try:
    import pyzipper
    ZIP_ENCRYPTION_AVAILABLE = True
except ImportError:
    ZIP_ENCRYPTION_AVAILABLE = False

class FileClassifier:
    """
    智能文件分類器
    根據(jù)文件類型、內(nèi)容、大小等特征自動分類文件
    """
    
    # 文件類型分類映射
    FILE_CATEGORIES = {
        'Images': {
            'extensions': ['.jpg', '.jpeg', '.png', '.gif', '.bmp', '.svg', '.webp', '.tiff', '.heic'],
            'mime_types': ['image/jpeg', 'image/png', 'image/gif', 'image/bmp', 'image/svg+xml'],
            'description': '圖片文件'
        },
        'Documents': {
            'extensions': ['.pdf', '.doc', '.docx', '.txt', '.rtf', '.xlsx', '.pptx', '.md', '.tex'],
            'mime_types': ['application/pdf', 'application/msword', 'text/plain'],
            'description': '文檔文件'
        },
        'Audio': {
            'extensions': ['.mp3', '.wav', '.flac', '.aac', '.ogg', '.m4a', '.wma'],
            'mime_types': ['audio/mpeg', 'audio/wav', 'audio/flac'],
            'description': '音頻文件'
        },
        'Video': {
            'extensions': ['.mp4', '.avi', '.mov', '.wmv', '.flv', '.mkv', '.webm'],
            'mime_types': ['video/mp4', 'video/avi', 'video/quicktime'],
            'description': '視頻文件'
        },
        'Archives': {
            'extensions': ['.zip', '.rar', '.7z', '.tar', '.gz', '.bz2'],
            'mime_types': ['application/zip', 'application/x-rar-compressed'],
            'description': '壓縮文件'
        },
        'Code': {
            'extensions': ['.py', '.js', '.html', '.css', '.java', '.cpp', '.c', '.php', '.rb', '.go'],
            'mime_types': ['text/x-python', 'application/javascript', 'text/html'],
            'description': '代碼文件'
        },
        'Executables': {
            'extensions': ['.exe', '.msi', '.dmg', '.pkg', '.deb', '.rpm', '.appimage'],
            'mime_types': ['application/x-msdownload', 'application/x-executable'],
            'description': '可執(zhí)行文件'
        },
        'Data': {
            'extensions': ['.csv', '.json', '.xml', '.sql', '.db', '.sqlite'],
            'mime_types': ['text/csv', 'application/json'],
            'description': '數(shù)據(jù)文件'
        }
    }
    
    def __init__(self, config_file: Optional[str] = None):
        """
        初始化文件分類器
        
        Args:
            config_file: 配置文件路徑
        """
        self.config = self.load_config(config_file)
        self.setup_logging()
        
    def setup_logging(self):
        """設置日志記錄"""
        logging.basicConfig(
            level=logging.INFO,
            format='%(asctime)s - %(levelname)s - %(message)s',
            handlers=[
                logging.FileHandler('file_classifier.log', encoding='utf-8'),
                logging.StreamHandler()
            ]
        )
        self.logger = logging.getLogger(__name__)
    
    def load_config(self, config_file: Optional[str]) -> Dict:
        """
        加載配置文件
        
        Args:
            config_file: 配置文件路徑
            
        Returns:
            Dict: 配置信息
        """
        default_config = {
            'organize_rules': {
                'create_date_folders': True,
                'use_nested_categories': False,
                'handle_duplicates': 'rename',  # 'rename', 'overwrite', 'skip'
                'default_category': 'Others',
                'max_filename_length': 255
            },
            'categories': self.FILE_CATEGORIES,
            'backup': {
                'enabled': False,
                'backup_before_organize': True,
                'backup_location': './backups'
            }
        }
        
        if config_file and Path(config_file).exists():
            try:
                with open(config_file, 'r', encoding='utf-8') as f:
                    if config_file.endswith('.json'):
                        user_config = json.load(f)
                    elif config_file.endswith(('.yaml', '.yml')):
                        user_config = yaml.safe_load(f)
                    else:
                        self.logger.warning(f"不支持的配置文件格式: {config_file}")
                        return default_config
                
                # 深度合并配置
                return self.deep_merge(default_config, user_config)
            except Exception as e:
                self.logger.error(f"加載配置文件失敗: {str(e)}")
        
        return default_config
    
    def deep_merge(self, base: Dict, update: Dict) -> Dict:
        """
        深度合并兩個字典
        
        Args:
            base: 基礎字典
            update: 更新字典
            
        Returns:
            Dict: 合并后的字典
        """
        result = base.copy()
        
        for key, value in update.items():
            if isinstance(value, dict) and key in result and isinstance(result[key], dict):
                result[key] = self.deep_merge(result[key], value)
            else:
                result[key] = value
        
        return result
    
    def detect_file_type(self, file_path: Path) -> Dict[str, str]:
        """
        檢測文件類型
        
        Args:
            file_path: 文件路徑
            
        Returns:
            Dict: 文件類型信息
        """
        file_info = {
            'extension': file_path.suffix.lower(),
            'mime_type': None,
            'size': file_path.stat().st_size,
            'created': datetime.fromtimestamp(file_path.stat().st_ctime),
            'modified': datetime.fromtimestamp(file_path.stat().st_mtime)
        }
        
        # 使用filetype庫檢測MIME類型
        try:
            kind = filetype.guess(str(file_path))
            if kind:
                file_info['mime_type'] = kind.mime
        except Exception as e:
            self.logger.debug(f"文件類型檢測失敗 {file_path}: {str(e)}")
        
        return file_info
    
    def classify_file(self, file_path: Path) -> str:
        """
        分類單個文件
        
        Args:
            file_path: 文件路徑
            
        Returns:
            str: 文件類別
        """
        if not file_path.is_file():
            return 'Invalid'
        
        file_info = self.detect_file_type(file_path)
        
        # 基于擴展名分類
        for category, config in self.config['categories'].items():
            if file_info['extension'] in config['extensions']:
                return category
        
        # 基于MIME類型分類
        if file_info['mime_type']:
            for category, config in self.config['categories'].items():
                if file_info['mime_type'] in config['mime_types']:
                    return category
        
        # 基于文件大小和內(nèi)容的啟發(fā)式分類
        special_category = self.special_classification(file_path, file_info)
        if special_category:
            return special_category
        
        return self.config['organize_rules']['default_category']
    
    def special_classification(self, file_path: Path, file_info: Dict) -> Optional[str]:
        """
        特殊分類邏輯
        
        Args:
            file_path: 文件路徑
            file_info: 文件信息
            
        Returns:
            Optional[str]: 特殊類別
        """
        # 大文件分類
        if file_info['size'] > 100 * 1024 * 1024:  # 100MB
            return 'Large_Files'
        
        # 臨時文件
        if file_path.name.startswith('~') or file_path.name.startswith('.'):
            return 'Temporary_Files'
        
        # 最近修改的文件
        if datetime.now() - file_info['modified'] < timedelta(days=7):
            return 'Recent_Files'
        
        return None
    
    def organize_directory(self, source_dir: Path, target_dir: Optional[Path] = None, 
                          dry_run: bool = False) -> Dict[str, List[Path]]:
        """
        整理目錄中的文件
        
        Args:
            source_dir: 源目錄
            target_dir: 目標目錄，如果為None則在原目錄整理
            dry_run: 試運行模式，不實際移動文件
            
        Returns:
            Dict: 分類結(jié)果
        """
        if not source_dir.exists():
            self.logger.error(f"源目錄不存在: {source_dir}")
            return {}
        
        if target_dir is None:
            target_dir = source_dir
        
        # 創(chuàng)建分類文件夾
        categories = list(self.config['categories'].keys()) + [
            self.config['organize_rules']['default_category'],
            'Large_Files', 'Temporary_Files', 'Recent_Files'
        ]
        
        for category in categories:
            category_dir = target_dir / category
            if not dry_run:
                category_dir.mkdir(exist_ok=True)
        
        classification_results = {category: [] for category in categories}
        classification_results['skipped'] = []
        classification_results['errors'] = []
        
        # 遍歷文件
        file_count = 0
        for file_path in source_dir.rglob('*'):
            if not file_path.is_file():
                continue
            
            # 跳過分類文件夾中的文件
            if any(category in file_path.parts for category in categories):
                continue
            
            file_count += 1
            
            try:
                category = self.classify_file(file_path)
                
                if dry_run:
                    classification_results[category].append(file_path)
                    self.logger.info(f"[試運行] {file_path.name} -> {category}/")
                else:
                    # 處理文件移動
                    success = self.move_to_category(file_path, target_dir / category, category)
                    if success:
                        classification_results[category].append(file_path)
                    else:
                        classification_results['errors'].append(file_path)
            
            except Exception as e:
                self.logger.error(f"處理文件失敗 {file_path}: {str(e)}")
                classification_results['errors'].append(file_path)
        
        # 生成報告
        self.generate_organization_report(classification_results, file_count, dry_run)
        
        return classification_results
    
    def move_to_category(self, source_file: Path, target_dir: Path, category: str) -> bool:
        """
        移動文件到分類目錄
        
        Args:
            source_file: 源文件
            target_dir: 目標目錄
            category: 文件類別
            
        Returns:
            bool: 移動是否成功
        """
        try:
            if not target_dir.exists():
                target_dir.mkdir(parents=True, exist_ok=True)
            
            target_file = target_dir / source_file.name
            
            # 處理文件名沖突
            if target_file.exists():
                handle_method = self.config['organize_rules']['handle_duplicates']
                if handle_method == 'rename':
                    target_file = self.generate_unique_filename(target_file)
                elif handle_method == 'skip':
                    self.logger.info(f"跳過已存在文件: {target_file}")
                    return False
                # 'overwrite' 則直接使用原文件名
            
            # 移動文件
            shutil.move(str(source_file), str(target_file))
            self.logger.info(f"已移動: {source_file.name} -> {category}/")
            return True
            
        except Exception as e:
            self.logger.error(f"移動文件失敗 {source_file} -> {target_dir}: {str(e)}")
            return False
    
    def generate_unique_filename(self, file_path: Path) -> Path:
        """
        生成唯一文件名
        
        Args:
            file_path: 原始文件路徑
            
        Returns:
            Path: 唯一文件路徑
        """
        counter = 1
        original_stem = file_path.stem
        extension = file_path.suffix
        
        while file_path.exists():
            new_name = f"{original_stem}_{counter}{extension}"
            file_path = file_path.parent / new_name
            counter += 1
        
        return file_path
    
    def generate_organization_report(self, results: Dict, total_files: int, dry_run: bool = False):
        """
        生成整理報告
        
        Args:
            results: 分類結(jié)果
            total_files: 總文件數(shù)
            dry_run: 是否為試運行
        """
        mode = "試運行" if dry_run else "實際執(zhí)行"
        
        self.logger.info(f"\n=== 文件整理報告 ({mode}) ===")
        self.logger.info(f"總文件數(shù): {total_files}")
        
        for category, files in results.items():
            if category not in ['skipped', 'errors'] and files:
                self.logger.info(f"{category}: {len(files)} 個文件")
        
        if results.get('skipped'):
            self.logger.info(f"跳過文件: {len(results['skipped'])} 個")
        
        if results.get('errors'):
            self.logger.warning(f"處理失敗: {len(results['errors'])} 個文件")

# 使用示例
def demo_file_classifier():
    """演示文件分類功能"""
    classifier = FileClassifier()
    
    # 創(chuàng)建測試目錄和文件
    test_dir = Path("test_files")
    test_dir.mkdir(exist_ok=True)
    
    # 創(chuàng)建一些測試文件
    test_files = {
        "document.pdf": "Documents",
        "image.jpg": "Images", 
        "music.mp3": "Audio",
        "video.mp4": "Video",
        "script.py": "Code",
        "data.csv": "Data",
        "archive.zip": "Archives"
    }
    
    for filename, expected_category in test_files.items():
        file_path = test_dir / filename
        file_path.touch()  # 創(chuàng)建空文件
        
        # 測試分類
        detected_category = classifier.classify_file(file_path)
        print(f"{filename}: 預期={expected_category}, 檢測={detected_category}")
    
    # 測試目錄整理（試運行）
    print("\n=== 目錄整理試運行 ===")
    results = classifier.organize_directory(test_dir, dry_run=True)
    
    # 清理測試文件
    for file_path in test_dir.iterdir():
        if file_path.is_file():
            file_path.unlink()
    test_dir.rmdir()
    
    return classifier

if __name__ == "__main__":
    demo_file_classifier()

class AdvancedFileClassifier(FileClassifier):
    """
    高級文件分類器
    擴展基礎功能，支持更復雜的分類策略
    """
    
    def __init__(self, config_file: Optional[str] = None):
        super().__init__(config_file)
        self.learning_data = self.load_learning_data()
    
    def load_learning_data(self) -> Dict:
        """
        加載學習數(shù)據(jù)（用于智能分類）
        
        Returns:
            Dict: 學習數(shù)據(jù)
        """
        data_file = Path("file_classification_learning.json")
        if data_file.exists():
            try:
                with open(data_file, 'r', encoding='utf-8') as f:
                    return json.load(f)
            except Exception as e:
                self.logger.error(f"加載學習數(shù)據(jù)失敗: {str(e)}")
        
        return {'file_patterns': {}, 'user_corrections': {}}
    
    def save_learning_data(self):
        """保存學習數(shù)據(jù)"""
        data_file = Path("file_classification_learning.json")
        try:
            with open(data_file, 'w', encoding='utf-8') as f:
                json.dump(self.learning_data, f, indent=2, ensure_ascii=False)
        except Exception as e:
            self.logger.error(f"保存學習數(shù)據(jù)失敗: {str(e)}")
    
    def learn_from_filename(self, filename: str, category: str):
        """
        從文件名學習分類模式
        
        Args:
            filename: 文件名
            category: 文件類別
        """
        # 提取文件名中的關(guān)鍵詞
        words = re.findall(r'[a-zA-Z]+', filename.lower())
        
        for word in words:
            if len(word) > 2:  # 忽略太短的詞
                if word not in self.learning_data['file_patterns']:
                    self.learning_data['file_patterns'][word] = {}
                
                if category not in self.learning_data['file_patterns'][word]:
                    self.learning_data['file_patterns'][word][category] = 0
                
                self.learning_data['file_patterns'][word][category] += 1
        
        self.save_learning_data()
    
    def classify_by_content(self, file_path: Path) -> Optional[str]:
        """
        基于內(nèi)容分類文件
        
        Args:
            file_path: 文件路徑
            
        Returns:
            Optional[str]: 分類結(jié)果
        """
        try:
            # 文本文件內(nèi)容分析
            if file_path.suffix.lower() in ['.txt', '.md', '.log']:
                return self.analyze_text_content(file_path)
            
            # 圖片文件分析
            if file_path.suffix.lower() in ['.jpg', '.jpeg', '.png'] and PIL_AVAILABLE:
                return self.analyze_image_content(file_path)
            
            # 代碼文件分析
            if file_path.suffix.lower() in ['.py', '.js', '.java', '.cpp']:
                return self.analyze_code_content(file_path)
            
        except Exception as e:
            self.logger.debug(f"內(nèi)容分析失敗 {file_path}: {str(e)}")
        
        return None
    
    def analyze_text_content(self, file_path: Path) -> Optional[str]:
        """
        分析文本文件內(nèi)容
        
        Args:
            file_path: 文件路徑
            
        Returns:
            Optional[str]: 分類結(jié)果
        """
        try:
            with open(file_path, 'r', encoding='utf-8', errors='ignore') as f:
                content = f.read().lower()
            
            # 基于關(guān)鍵詞分類
            category_keywords = {
                'log': ['error', 'warning', 'debug', 'info', 'exception'],
                'config': ['config', 'setting', 'property', 'environment'],
                'documentation': ['readme', 'license', 'install', 'usage']
            }
            
            for category, keywords in category_keywords.items():
                if any(keyword in content for keyword in keywords):
                    return f"Text_{category.capitalize()}"
            
        except Exception as e:
            self.logger.debug(f"文本分析失敗 {file_path}: {str(e)}")
        
        return None
    
    def analyze_image_content(self, file_path: Path) -> Optional[str]:
        """
        分析圖片文件內(nèi)容
        
        Args:
            file_path: 文件路徑
            
        Returns:
            Optional[str]: 分類結(jié)果
        """
        if not PIL_AVAILABLE:
            return None
        
        try:
            with Image.open(file_path) as img:
                width, height = img.size
                
                # 根據(jù)圖片尺寸分類
                if width > 2000 or height > 2000:
                    return "Images_High_Resolution"
                elif width < 500 and height < 500:
                    return "Images_Thumbnails"
                else:
                    return "Images_Standard"
                    
        except Exception as e:
            self.logger.debug(f"圖片分析失敗 {file_path}: {str(e)}")
        
        return None
    
    def analyze_code_content(self, file_path: Path) -> Optional[str]:
        """
        分析代碼文件內(nèi)容
        
        Args:
            file_path: 文件路徑
            
        Returns:
            Optional[str]: 分類結(jié)果
        """
        try:
            with open(file_path, 'r', encoding='utf-8', errors='ignore') as f:
                content = f.read()
            
            # 檢測代碼類型
            if 'import tensorflow' in content or 'import torch' in content:
                return "Code_ML"
            elif 'from flask' in content or 'from django' in content:
                return "Code_Web"
            elif 'class ' in content and 'def ' in content:
                return "Code_OOP"
            else:
                return "Code_Scripts"
                
        except Exception as e:
            self.logger.debug(f"代碼分析失敗 {file_path}: {str(e)}")
        
        return None
    
    def smart_classify_file(self, file_path: Path) -> str:
        """
        智能文件分類（結(jié)合多種策略）
        
        Args:
            file_path: 文件路徑
            
        Returns:
            str: 分類結(jié)果
        """
        # 1. 基礎分類
        base_category = super().classify_file(file_path)
        
        # 2. 內(nèi)容分類
        content_category = self.classify_by_content(file_path)
        if content_category:
            return content_category
        
        # 3. 基于學習數(shù)據(jù)的分類
        learned_category = self.classify_by_learning(file_path.name)
        if learned_category and learned_category != base_category:
            self.logger.info(f"基于學習數(shù)據(jù)重新分類: {file_path.name} -> {learned_category}")
            return learned_category
        
        return base_category
    
    def classify_by_learning(self, filename: str) -> Optional[str]:
        """
        基于學習數(shù)據(jù)分類
        
        Args:
            filename: 文件名
            
        Returns:
            Optional[str]: 分類結(jié)果
        """
        words = re.findall(r'[a-zA-Z]+', filename.lower())
        category_scores = {}
        
        for word in words:
            if word in self.learning_data['file_patterns']:
                for category, count in self.learning_data['file_patterns'][word].items():
                    if category not in category_scores:
                        category_scores[category] = 0
                    category_scores[category] += count
        
        if category_scores:
            best_category = max(category_scores.items(), key=lambda x: x[1])[0]
            return best_category
        
        return None

# 使用示例
def demo_advanced_classifier():
    """演示高級分類功能"""
    classifier = AdvancedFileClassifier()
    
    # 測試學習功能
    test_files = [
        ("error_log_2024.txt", "Text_Log"),
        ("config_settings.json", "Text_Config"), 
        ("model_training.py", "Code_ML"),
        ("web_app.py", "Code_Web")
    ]
    
    for filename, category in test_files:
        classifier.learn_from_filename(filename, category)
        print(f"學習: {filename} -> {category}")
    
    # 測試智能分類
    test_file = Path("test_model.py")
    test_file.touch()
    
    category = classifier.smart_classify_file(test_file)
    print(f"智能分類: {test_file.name} -> {category}")
    
    test_file.unlink()
    
    return classifier

if __name__ == "__main__":
    demo_advanced_classifier()

class FileRenamer:
    """
    智能文件重命名器
    提供多種重命名策略和批量操作
    """
    
    def __init__(self):
        self.setup_logging()
        self.rename_history = []
    
    def setup_logging(self):
        """設置日志記錄"""
        logging.basicConfig(
            level=logging.INFO,
            format='%(asctime)s - %(levelname)s - %(message)s'
        )
        self.logger = logging.getLogger(__name__)
    
    def bulk_rename(self, directory: Path, pattern: str, 
                   naming_strategy: str = "sequential", 
                   start_number: int = 1, dry_run: bool = False) -> List[Tuple[Path, Path]]:
        """
        批量重命名文件
        
        Args:
            directory: 目錄路徑
            pattern: 文件名模式（支持變量）
            naming_strategy: 命名策略
            start_number: 起始編號
            dry_run: 試運行模式
            
        Returns:
            List: 重命名結(jié)果列表 (原路徑, 新路徑)
        """
        if not directory.exists():
            self.logger.error(f"目錄不存在: {directory}")
            return []
        
        # 獲取文件列表
        files = self.get_files_for_renaming(directory)
        if not files:
            self.logger.warning(f"目錄中沒有可重命名的文件: {directory}")
            return []
        
        # 根據(jù)策略排序文件
        sorted_files = self.sort_files(files, naming_strategy)
        
        # 生成新文件名
        rename_plan = self.generate_rename_plan(sorted_files, pattern, start_number)
        
        # 執(zhí)行重命名
        results = []
        for old_path, new_path in rename_plan:
            if dry_run:
                self.logger.info(f"[試運行] 重命名: {old_path.name} -> {new_path.name}")
                results.append((old_path, new_path))
            else:
                success = self.safe_rename(old_path, new_path)
                if success:
                    results.append((old_path, new_path))
                    self.rename_history.append((old_path, new_path))
        
        self.logger.info(f"重命名完成: {len(results)}/{len(files)} 個文件")
        return results
    
    def get_files_for_renaming(self, directory: Path) -> List[Path]:
        """
        獲取需要重命名的文件列表
        
        Args:
            directory: 目錄路徑
            
        Returns:
            List: 文件路徑列表
        """
        files = []
        for item in directory.iterdir():
            if item.is_file() and not item.name.startswith('.'):
                files.append(item)
        return files
    
    def sort_files(self, files: List[Path], strategy: str) -> List[Path]:
        """
        根據(jù)策略排序文件
        
        Args:
            files: 文件列表
            strategy: 排序策略
            
        Returns:
            List: 排序后的文件列表
        """
        if strategy == "creation_time":
            return sorted(files, key=lambda x: x.stat().st_ctime)
        elif strategy == "modified_time":
            return sorted(files, key=lambda x: x.stat().st_mtime)
        elif strategy == "size":
            return sorted(files, key=lambda x: x.stat().st_size)
        elif strategy == "name":
            return sorted(files, key=lambda x: x.name.lower())
        else:  # sequential 或其他
            return files
    
    def generate_rename_plan(self, files: List[Path], pattern: str, 
                           start_number: int) -> List[Tuple[Path, Path]]:
        """
        生成重命名計劃
        
        Args:
            files: 文件列表
            pattern: 文件名模式
            start_number: 起始編號
            
        Returns:
            List: 重命名計劃
        """
        rename_plan = []
        
        for i, file_path in enumerate(files, start_number):
            new_name = self.generate_new_filename(file_path, pattern, i)
            new_path = file_path.parent / new_name
            rename_plan.append((file_path, new_path))
        
        return rename_plan
    
    def generate_new_filename(self, file_path: Path, pattern: str, number: int) -> str:
        """
        生成新文件名
        
        Args:
            file_path: 原文件路徑
            pattern: 文件名模式
            number: 序號
            
        Returns:
            str: 新文件名
        """
        # 支持的模式變量
        variables = {
            '{number}': f"{number:04d}",  # 4位數(shù)字，前面補零
            '{index}': str(number),
            '{name}': file_path.stem,
            '{ext}': file_path.suffix[1:],  # 去掉點號
            '{full_ext}': file_path.suffix,
            '{date}': datetime.now().strftime('%Y%m%d'),
            '{time}': datetime.now().strftime('%H%M%S'),
            '{datetime}': datetime.now().strftime('%Y%m%d_%H%M%S')
        }
        
        new_name = pattern
        for var, value in variables.items():
            new_name = new_name.replace(var, value)
        
        # 確保文件名合法
        new_name = self.sanitize_filename(new_name)
        
        return new_name
    
    def sanitize_filename(self, filename: str) -> str:
        """
        清理文件名，移除非法字符
        
        Args:
            filename: 原文件名
            
        Returns:
            str: 清理后的文件名
        """
        # 移除非法字符
        illegal_chars = r'[<>:"/\\|?*\x00-\x1f]'
        sanitized = re.sub(illegal_chars, '_', filename)
        
        # 限制文件名長度
        max_length = 255
        if len(sanitized) > max_length:
            name, ext = os.path.splitext(sanitized)
            sanitized = name[:max_length - len(ext)] + ext
        
        return sanitized
    
    def safe_rename(self, old_path: Path, new_path: Path) -> bool:
        """
        安全重命名文件（處理沖突）
        
        Args:
            old_path: 原路徑
            new_path: 新路徑
            
        Returns:
            bool: 重命名是否成功
        """
        try:
            # 如果目標文件已存在，生成新名稱
            counter = 1
            original_new_path = new_path
            while new_path.exists():
                stem = original_new_path.stem
                extension = original_new_path.suffix
                new_name = f"{stem}_{counter}{extension}"
                new_path = original_new_path.parent / new_name
                counter += 1
            
            old_path.rename(new_path)
            self.logger.info(f"重命名: {old_path.name} -> {new_path.name}")
            return True
            
        except Exception as e:
            self.logger.error(f"重命名失敗 {old_path} -> {new_path}: {str(e)}")
            return False
    
    def rename_with_regex(self, directory: Path, search_pattern: str, 
                         replace_pattern: str, dry_run: bool = False) -> List[Tuple[Path, Path]]:
        """
        使用正則表達式重命名文件
        
        Args:
            directory: 目錄路徑
            search_pattern: 搜索模式（正則表達式）
            replace_pattern: 替換模式
            dry_run: 試運行模式
            
        Returns:
            List: 重命名結(jié)果
        """
        if not directory.exists():
            self.logger.error(f"目錄不存在: {directory}")
            return []
        
        results = []
        
        for file_path in directory.iterdir():
            if not file_path.is_file():
                continue
            
            try:
                new_name = re.sub(search_pattern, replace_pattern, file_path.name)
                if new_name != file_path.name:
                    new_path = file_path.parent / new_name
                    
                    if dry_run:
                        self.logger.info(f"[試運行] 正則重命名: {file_path.name} -> {new_name}")
                        results.append((file_path, new_path))
                    else:
                        success = self.safe_rename(file_path, new_path)
                        if success:
                            results.append((file_path, new_path))
                            self.rename_history.append((file_path, new_path))
            
            except Exception as e:
                self.logger.error(f"正則重命名失敗 {file_path}: {str(e)}")
        
        return results
    
    def undo_last_rename(self) -> bool:
        """
        撤銷最后一次重命名操作
        
        Returns:
            bool: 撤銷是否成功
        """
        if not self.rename_history:
            self.logger.warning("沒有可撤銷的重命名操作")
            return False
        
        try:
            # 從最近的操作開始撤銷
            for old_path, new_path in reversed(self.rename_history):
                if new_path.exists():
                    new_path.rename(old_path)
                    self.logger.info(f"撤銷重命名: {new_path.name} -> {old_path.name}")
            
            self.rename_history.clear()
            self.logger.info("所有重命名操作已撤銷")
            return True
            
        except Exception as e:
            self.logger.error(f"撤銷重命名失敗: {str(e)}")
            return False

# 使用示例
def demo_file_renamer():
    """演示文件重命名功能"""
    renamer = FileRenamer()
    
    # 創(chuàng)建測試目錄和文件
    test_dir = Path("test_rename")
    test_dir.mkdir(exist_ok=True)
    
    # 創(chuàng)建測試文件
    test_files = ["photo1.jpg", "document1.pdf", "music1.mp3", "data1.csv"]
    for filename in test_files:
        file_path = test_dir / filename
        file_path.touch()
    
    # 測試批量重命名（試運行）
    print("=== 批量重命名試運行 ===")
    results = renamer.bulk_rename(
        directory=test_dir,
        pattern="file_{number}{full_ext}",
        naming_strategy="name",
        start_number=1,
        dry_run=True
    )
    
    # 測試正則重命名（試運行）
    print("\n=== 正則重命名試運行 ===")
    regex_results = renamer.rename_with_regex(
        directory=test_dir,
        search_pattern=r"(\d+)",
        replace_pattern=r"_\1",
        dry_run=True
    )
    
    # 清理測試文件
    for file_path in test_dir.iterdir():
        if file_path.is_file():
            file_path.unlink()
    test_dir.rmdir()
    
    return renamer

if __name__ == "__main__":
    demo_file_renamer()

class BackupManager:
    """
    智能備份管理器
    提供完整的文件備份解決方案
    """
    
    def __init__(self, config_file: Optional[str] = None):
        """
        初始化備份管理器
        
        Args:
            config_file: 配置文件路徑
        """
        self.config = self.load_config(config_file)
        self.setup_logging()
        self.backup_history = []
    
    def setup_logging(self):
        """設置日志記錄"""
        logging.basicConfig(
            level=logging.INFO,
            format='%(asctime)s - %(levelname)s - %(message)s',
            handlers=[
                logging.FileHandler('backup_manager.log', encoding='utf-8'),
                logging.StreamHandler()
            ]
        )
        self.logger = logging.getLogger(__name__)
    
    def load_config(self, config_file: Optional[str]) -> Dict:
        """
        加載備份配置
        
        Args:
            config_file: 配置文件路徑
            
        Returns:
            Dict: 備份配置
        """
        default_config = {
            'backup_locations': {
                'local': './backups',
                'external': None  # 例如: 'D:/Backups' 或 '/mnt/backup'
            },
            'compression': {
                'enabled': True,
                'format': 'zip',  # 'zip', 'tar', 'tar.gz'
                'compression_level': 6
            },
            'encryption': {
                'enabled': False,
                'password': None
            },
            'retention': {
                'keep_daily': 7,
                'keep_weekly': 4,
                'keep_monthly': 12,
                'max_total_size': '10GB'  # 例如: '10GB', '1TB'
            },
            'scheduling': {
                'auto_backup': False,
                'backup_times': ['02:00']  # 每天備份時間
            }
        }
        
        if config_file and Path(config_file).exists():
            try:
                with open(config_file, 'r', encoding='utf-8') as f:
                    if config_file.endswith('.json'):
                        user_config = json.load(f)
                    elif config_file.endswith(('.yaml', '.yml')):
                        user_config = yaml.safe_load(f)
                    else:
                        self.logger.warning(f"不支持的配置文件格式: {config_file}")
                        return default_config
                
                return self.deep_merge(default_config, user_config)
            except Exception as e:
                self.logger.error(f"加載配置文件失敗: {str(e)}")
        
        return default_config
    
    def deep_merge(self, base: Dict, update: Dict) -> Dict:
        """
        深度合并配置
        
        Args:
            base: 基礎配置
            update: 更新配置
            
        Returns:
            Dict: 合并后的配置
        """
        result = base.copy()
        
        for key, value in update.items():
            if isinstance(value, dict) and key in result and isinstance(result[key], dict):
                result[key] = self.deep_merge(result[key], value)
            else:
                result[key] = value
        
        return result
    
    def create_backup(self, source_path: Path, backup_name: str = None, 
                     incremental: bool = False) -> Optional[Path]:
        """
        創(chuàng)建備份
        
        Args:
            source_path: 源路徑（文件或目錄）
            backup_name: 備份名稱
            incremental: 是否使用增量備份
            
        Returns:
            Optional[Path]: 備份文件路徑
        """
        if not source_path.exists():
            self.logger.error(f"源路徑不存在: {source_path}")
            return None
        
        # 生成備份名稱
        if backup_name is None:
            timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
            if source_path.is_file():
                backup_name = f"{source_path.stem}_{timestamp}"
            else:
                backup_name = f"{source_path.name}_{timestamp}"
        
        # 確定備份位置
        backup_dir = Path(self.config['backup_locations']['local'])
        backup_dir.mkdir(parents=True, exist_ok=True)
        
        try:
            if incremental and source_path.is_dir():
                # 增量備份
                backup_path = self.create_incremental_backup(source_path, backup_dir, backup_name)
            else:
                # 完整備份
                if source_path.is_file():
                    backup_path = self.backup_file(source_path, backup_dir, backup_name)
                else:
                    backup_path = self.backup_directory(source_path, backup_dir, backup_name)
            
            if backup_path:
                self.backup_history.append({
                    'timestamp': datetime.now(),
                    'source': source_path,
                    'backup_path': backup_path,
                    'type': 'incremental' if incremental else 'full',
                    'size': backup_path.stat().st_size if backup_path.exists() else 0
                })
                
                self.logger.info(f"備份創(chuàng)建成功: {backup_path}")
                return backup_path
        
        except Exception as e:
            self.logger.error(f"創(chuàng)建備份失敗: {str(e)}")
        
        return None
    
    def backup_file(self, source_file: Path, backup_dir: Path, backup_name: str) -> Optional[Path]:
        """
        備份單個文件
        
        Args:
            source_file: 源文件
            backup_dir: 備份目錄
            backup_name: 備份名稱
            
        Returns:
            Optional[Path]: 備份文件路徑
        """
        try:
            if self.config['compression']['enabled']:
                # 壓縮備份
                backup_path = backup_dir / f"{backup_name}.{self.config['compression']['format']}"
                self.compress_files([source_file], backup_path)
            else:
                # 直接復制
                backup_path = backup_dir / f"{backup_name}{source_file.suffix}"
                shutil.copy2(source_file, backup_path)
            
            return backup_path
            
        except Exception as e:
            self.logger.error(f"備份文件失敗 {source_file}: {str(e)}")
            return None
    
    def backup_directory(self, source_dir: Path, backup_dir: Path, backup_name: str) -> Optional[Path]:
        """
        備份整個目錄
        
        Args:
            source_dir: 源目錄
            backup_dir: 備份目錄
            backup_name: 備份名稱
            
        Returns:
            Optional[Path]: 備份文件路徑
        """
        try:
            if self.config['compression']['enabled']:
                # 壓縮備份整個目錄
                backup_path = backup_dir / f"{backup_name}.{self.config['compression']['format']}"
                self.compress_directory(source_dir, backup_path)
            else:
                # 直接復制目錄
                backup_path = backup_dir / backup_name
                shutil.copytree(source_dir, backup_path)
            
            return backup_path
            
        except Exception as e:
            self.logger.error(f"備份目錄失敗 {source_dir}: {str(e)}")
            return None
    
    def compress_files(self, files: List[Path], output_path: Path):
        """
        壓縮文件列表
        
        Args:
            files: 文件列表
            output_path: 輸出路徑
        """
        compression_format = self.config['compression']['format']
        
        if compression_format == 'zip':
            self.create_zip_archive(files, output_path)
        elif compression_format in ['tar', 'tar.gz']:
            self.create_tar_archive(files, output_path)
        else:
            raise ValueError(f"不支持的壓縮格式: {compression_format}")
    
    def compress_directory(self, directory: Path, output_path: Path):
        """
        壓縮整個目錄
        
        Args:
            directory: 目錄路徑
            output_path: 輸出路徑
        """
        compression_format = self.config['compression']['format']
        
        if compression_format == 'zip':
            self.create_zip_archive([directory], output_path)
        elif compression_format in ['tar', 'tar.gz']:
            self.create_tar_archive([directory], output_path)
        else:
            raise ValueError(f"不支持的壓縮格式: {compression_format}")
    
    def create_zip_archive(self, items: List[Path], output_path: Path):
        """
        創(chuàng)建ZIP壓縮包
        
        Args:
            items: 要壓縮的項目列表
            output_path: 輸出路徑
        """
        compression_level = self.config['compression']['compression_level']
        
        if self.config['encryption']['enabled'] and ZIP_ENCRYPTION_AVAILABLE:
            # 加密ZIP
            password = self.config['encryption']['password']
            if not password:
                raise ValueError("加密已啟用但未設置密碼")
            
            with pyzipper.AESZipFile(
                output_path, 'w',
                compression=pyzipper.ZIP_DEFLATED,
                compresslevel=compression_level,
                encryption=pyzipper.WZ_AES
            ) as zipf:
                zipf.setpassword(password.encode('utf-8'))
                self.add_items_to_zip(zipf, items)
        else:
            # 普通ZIP
            with zipfile.ZipFile(
                output_path, 'w',
                compression=zipfile.ZIP_DEFLATED,
                compresslevel=compression_level
            ) as zipf:
                self.add_items_to_zip(zipf, items)
    
    def add_items_to_zip(self, zipf, items: List[Path], base_path: Path = None):
        """
        添加項目到ZIP文件
        
        Args:
            zipf: ZIP文件對象
            items: 項目列表
            base_path: 基礎路徑（用于相對路徑）
        """
        for item in items:
            if base_path is None:
                base_path = item.parent
            
            if item.is_file():
                # 添加文件
                arcname = item.relative_to(base_path)
                zipf.write(item, arcname)
            elif item.is_dir():
                # 遞歸添加目錄
                for file_path in item.rglob('*'):
                    if file_path.is_file():
                        arcname = file_path.relative_to(base_path)
                        zipf.write(file_path, arcname)
    
    def create_tar_archive(self, items: List[Path], output_path: Path):
        """
        創(chuàng)建TAR壓縮包
        
        Args:
            items: 要壓縮的項目列表
            output_path: 輸出路徑
        """
        import tarfile
        
        mode = 'w'
        if self.config['compression']['format'] == 'tar.gz':
            mode = 'w:gz'
        
        with tarfile.open(output_path, mode) as tar:
            for item in items:
                tar.add(item, arcname=item.name)
    
    def create_incremental_backup(self, source_dir: Path, backup_dir: Path, 
                                backup_name: str) -> Optional[Path]:
        """
        創(chuàng)建增量備份
        
        Args:
            source_dir: 源目錄
            backup_dir: 備份目錄
            backup_name: 備份名稱
            
        Returns:
            Optional[Path]: 備份文件路徑
        """
        try:
            # 獲取上次備份時間
            last_backup_time = self.get_last_backup_time(source_dir)
            
            # 查找自上次備份以來修改的文件
            changed_files = self.get_changed_files(source_dir, last_backup_time)
            
            if not changed_files:
                self.logger.info("沒有檢測到文件變化，跳過增量備份")
                return None
            
            # 創(chuàng)建增量備份
            timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
            backup_path = backup_dir / f"{backup_name}_incremental_{timestamp}.zip"
            
            self.compress_files(changed_files, backup_path)
            
            self.logger.info(f"增量備份創(chuàng)建成功: {len(changed_files)} 個文件")
            return backup_path
            
        except Exception as e:
            self.logger.error(f"創(chuàng)建增量備份失敗: {str(e)}")
            return None
    
    def get_last_backup_time(self, source_dir: Path) -> Optional[datetime]:
        """
        獲取上次備份時間
        
        Args:
            source_dir: 源目錄
            
        Returns:
            Optional[datetime]: 上次備份時間
        """
        # 查找該目錄的最近備份
        relevant_backups = [
            entry for entry in self.backup_history 
            if entry['source'] == source_dir
        ]
        
        if relevant_backups:
            return max(entry['timestamp'] for entry in relevant_backups)
        
        return None
    
    def get_changed_files(self, source_dir: Path, since_time: Optional[datetime]) -> List[Path]:
        """
        獲取自指定時間以來修改的文件
        
        Args:
            source_dir: 源目錄
            since_time: 起始時間
            
        Returns:
            List[Path]: 修改的文件列表
        """
        changed_files = []
        
        for file_path in source_dir.rglob('*'):
            if file_path.is_file():
                file_mtime = datetime.fromtimestamp(file_path.stat().st_mtime)
                
                # 如果沒有指定時間，或者文件在指定時間后修改過
                if since_time is None or file_mtime > since_time:
                    changed_files.append(file_path)
        
        return changed_files
    
    def restore_backup(self, backup_path: Path, target_path: Path, 
                      overwrite: bool = False) -> bool:
        """
        恢復備份
        
        Args:
            backup_path: 備份文件路徑
            target_path: 恢復目標路徑
            overwrite: 是否覆蓋現(xiàn)有文件
            
        Returns:
            bool: 恢復是否成功
        """
        if not backup_path.exists():
            self.logger.error(f"備份文件不存在: {backup_path}")
            return False
        
        try:
            if backup_path.suffix.lower() in ['.zip', '.tar', '.gz']:
                # 解壓恢復
                self.extract_backup(backup_path, target_path, overwrite)
            else:
                # 直接復制恢復
                if target_path.exists() and not overwrite:
                    self.logger.error(f"目標路徑已存在: {target_path}")
                    return False
                shutil.copy2(backup_path, target_path)
            
            self.logger.info(f"備份恢復成功: {backup_path} -> {target_path}")
            return True
            
        except Exception as e:
            self.logger.error(f"恢復備份失敗: {str(e)}")
            return False
    
    def extract_backup(self, backup_path: Path, target_path: Path, overwrite: bool = False):
        """
        解壓備份文件
        
        Args:
            backup_path: 備份文件路徑
            target_path: 目標路徑
            overwrite: 是否覆蓋
        """
        if backup_path.suffix.lower() == '.zip':
            # 處理加密ZIP
            if self.config['encryption']['enabled'] and ZIP_ENCRYPTION_AVAILABLE:
                password = self.config['encryption']['password']
                with pyzipper.AESZipFile(backup_path) as zipf:
                    zipf.setpassword(password.encode('utf-8'))
                    zipf.extractall(target_path)
            else:
                with zipfile.ZipFile(backup_path) as zipf:
                    zipf.extractall(target_path)
        
        elif backup_path.suffix.lower() in ['.tar', '.gz']:
            import tarfile
            with tarfile.open(backup_path) as tar:
                tar.extractall(target_path)
    
    def cleanup_old_backups(self) -> int:
        """
        清理舊備份
        
        Returns:
            int: 刪除的備份數(shù)量
        """
        backup_dir = Path(self.config['backup_locations']['local'])
        if not backup_dir.exists():
            return 0
        
        deleted_count = 0
        retention_config = self.config['retention']
        
        try:
            # 獲取所有備份文件
            backup_files = list(backup_dir.glob('*'))
            backup_files.sort(key=lambda x: x.stat().st_mtime)
            
            # 這里可以實現(xiàn)復雜的保留策略
            # 簡化實現(xiàn)：按數(shù)量保留
            max_backups = 10  # 默認保留10個備份
            if len(backup_files) > max_backups:
                files_to_delete = backup_files[:-max_backups]
                
                for file_path in files_to_delete:
                    file_path.unlink()
                    deleted_count += 1
                    self.logger.info(f"刪除舊備份: {file_path.name}")
        
        except Exception as e:
            self.logger.error(f"清理舊備份失敗: {str(e)}")
        
        return deleted_count

# 使用示例
def demo_backup_manager():
    """演示備份管理功能"""
    backup_mgr = BackupManager()
    
    # 創(chuàng)建測試目錄和文件
    test_dir = Path("test_backup_source")
    test_dir.mkdir(exist_ok=True)
    
    # 創(chuàng)建測試文件
    test_files = ["important_document.txt", "precious_photo.jpg", "critical_data.csv"]
    for filename in test_files:
        file_path = test_dir / filename
        file_path.write_text(f"這是 {filename} 的內(nèi)容")
    
    # 測試完整備份
    print("=== 創(chuàng)建完整備份 ===")
    backup_path = backup_mgr.create_backup(test_dir, "test_backup")
    if backup_path:
        print(f"備份創(chuàng)建成功: {backup_path}")
    
    # 測試增量備份
    print("\n=== 創(chuàng)建增量備份 ===")
    # 修改一個文件以觸發(fā)增量備份
    (test_dir / "important_document.txt").write_text("修改后的內(nèi)容")
    
    incremental_backup = backup_mgr.create_backup(test_dir, "test_backup", incremental=True)
    if incremental_backup:
        print(f"增量備份創(chuàng)建成功: {incremental_backup}")
    
    # 測試恢復
    print("\n=== 測試備份恢復 ===")
    restore_dir = Path("test_restore")
    if backup_path and backup_mgr.restore_backup(backup_path, restore_dir):
        print(f"備份恢復成功: {restore_dir}")
    
    # 清理測試文件
    for file_path in test_dir.iterdir():
        file_path.unlink()
    test_dir.rmdir()
    
    if restore_dir.exists():
        for file_path in restore_dir.iterdir():
            file_path.unlink()
        restore_dir.rmdir()
    
    return backup_mgr

if __name__ == "__main__":
    demo_backup_manager()

"""
自動化文件管理系統(tǒng) - 完整代碼實現(xiàn)
包含文件分類、重命名和備份
日期: 2024年
"""

import os
import shutil
import re
import hashlib
import json
import yaml
import zipfile
import logging
from pathlib import Path
from datetime import datetime, timedelta
from typing import List, Dict, Optional, Tuple, Callable
from dataclasses import dataclass
from enum import Enum
from tqdm import tqdm

# 可選依賴
try:
    from PIL import Image
    PIL_AVAILABLE = True
except ImportError:
    PIL_AVAILABLE = False

try:
    import pyzipper
    ZIP_ENCRYPTION_AVAILABLE = True
except ImportError:
    ZIP_ENCRYPTION_AVAILABLE = False

try:
    import filetype
    FILETYPE_AVAILABLE = True
except ImportError:
    FILETYPE_AVAILABLE = False

@dataclass
class FileOperationResult:
    """文件操作結(jié)果"""
    success: bool
    message: str
    details: Dict = None

class FileCategory(Enum):
    """文件類別枚舉"""
    IMAGES = "Images"
    DOCUMENTS = "Documents"
    AUDIO = "Audio"
    VIDEO = "Video"
    ARCHIVES = "Archives"
    CODE = "Code"
    EXECUTABLES = "Executables"
    DATA = "Data"
    OTHERS = "Others"

class AutomatedFileManager:
    """
    自動化文件管理器
    集成文件分類、重命名和備份功能
    """
    
    def __init__(self, config_file: Optional[str] = None):
        """
        初始化文件管理器
        
        Args:
            config_file: 配置文件路徑
        """
        self.config_file = config_file
        self.config = self.load_config()
        self.setup_logging()
        
        # 初始化組件
        self.classifier = FileClassifier(config_file)
        self.renamer = FileRenamer()
        self.backup_mgr = BackupManager(config_file)
        
        self.operation_history = []
    
    def setup_logging(self):
        """設置日志記錄"""
        logging.basicConfig(
            level=logging.INFO,
            format='%(asctime)s - %(levelname)s - %(message)s',
            handlers=[
                logging.FileHandler('file_manager.log', encoding='utf-8'),
                logging.StreamHandler()
            ]
        )
        self.logger = logging.getLogger(__name__)
    
    def load_config(self) -> Dict:
        """加載配置文件"""
        default_config = {
            'general': {
                'max_file_size': '10GB',
                'default_encoding': 'utf-8',
                'backup_before_operations': True
            },
            'classification': {
                'enabled': True,
                'auto_organize': False,
                'categories': FileClassifier.FILE_CATEGORIES
            },
            'renaming': {
                'enabled': True,
                'default_pattern': '{name}{full_ext}',
                'backup_original': True
            },
            'backup': {
                'enabled': True,
                'auto_cleanup': True,
                'compression': True
            }
        }
        
        if self.config_file and Path(self.config_file).exists():
            try:
                with open(self.config_file, 'r', encoding='utf-8') as f:
                    if self.config_file.endswith('.json'):
                        user_config = json.load(f)
                    elif self.config_file.endswith(('.yaml', '.yml')):
                        user_config = yaml.safe_load(f)
                    else:
                        self.logger.warning(f"不支持的配置文件格式: {self.config_file}")
                        return default_config
                
                return self.deep_merge(default_config, user_config)
            except Exception as e:
                self.logger.error(f"加載配置文件失敗: {str(e)}")
        
        return default_config
    
    def deep_merge(self, base: Dict, update: Dict) -> Dict:
        """深度合并配置"""
        result = base.copy()
        
        for key, value in update.items():
            if isinstance(value, dict) and key in result and isinstance(result[key], dict):
                result[key] = self.deep_merge(result[key], value)
            else:
                result[key] = value
        
        return result
    
    def organize_directory(self, directory: Path, target_dir: Optional[Path] = None,
                          dry_run: bool = False) -> FileOperationResult:
        """
        整理目錄
        
        Args:
            directory: 要整理的目錄
            target_dir: 目標目錄
            dry_run: 試運行模式
            
        Returns:
            FileOperationResult: 操作結(jié)果
        """
        try:
            if not directory.exists():
                return FileOperationResult(False, f"目錄不存在: {directory}")
            
            # 備份檢查
            if self.config['general']['backup_before_operations'] and not dry_run:
                self.logger.info("創(chuàng)建操作前備份...")
                backup_path = self.backup_mgr.create_backup(directory, "pre_organization")
                if backup_path:
                    self.logger.info(f"備份已創(chuàng)建: {backup_path}")
            
            # 執(zhí)行分類整理
            results = self.classifier.organize_directory(directory, target_dir, dry_run)
            
            # 生成報告
            total_files = sum(len(files) for files in results.values())
            moved_files = total_files - len(results.get('skipped', [])) - len(results.get('errors', []))
            
            message = f"整理完成: 移動 {moved_files}/{total_files} 個文件"
            details = {
                'total_files': total_files,
                'moved_files': moved_files,
                'skipped_files': len(results.get('skipped', [])),
                'errors': len(results.get('errors', [])),
                'categories': {k: len(v) for k, v in results.items() 
                             if k not in ['skipped', 'errors'] and v}
            }
            
            self.operation_history.append({
                'timestamp': datetime.now(),
                'operation': 'organize_directory',
                'directory': directory,
                'result': details
            })
            
            return FileOperationResult(True, message, details)
            
        except Exception as e:
            error_msg = f"整理目錄失敗: {str(e)}"
            self.logger.error(error_msg)
            return FileOperationResult(False, error_msg)
    
    def bulk_rename(self, directory: Path, pattern: str, 
                   naming_strategy: str = "sequential", 
                   start_number: int = 1, dry_run: bool = False) -> FileOperationResult:
        """
        批量重命名
        
        Args:
            directory: 目錄路徑
            pattern: 文件名模式
            naming_strategy: 命名策略
            start_number: 起始編號
            dry_run: 試運行模式
            
        Returns:
            FileOperationResult: 操作結(jié)果
        """
        try:
            if not directory.exists():
                return FileOperationResult(False, f"目錄不存在: {directory}")
            
            # 備份檢查
            if self.config['general']['backup_before_operations'] and not dry_run:
                self.logger.info("創(chuàng)建操作前備份...")
                backup_path = self.backup_mgr.create_backup(directory, "pre_renaming")
                if backup_path:
                    self.logger.info(f"備份已創(chuàng)建: {backup_path}")
            
            # 執(zhí)行重命名
            results = self.renamer.bulk_rename(
                directory, pattern, naming_strategy, start_number, dry_run
            )
            
            message = f"重命名完成: {len(results)} 個文件"
            details = {
                'renamed_files': len(results),
                'pattern': pattern,
                'strategy': naming_strategy
            }
            
            self.operation_history.append({
                'timestamp': datetime.now(),
                'operation': 'bulk_rename',
                'directory': directory,
                'result': details
            })
            
            return FileOperationResult(True, message, details)
            
        except Exception as e:
            error_msg = f"批量重命名失敗: {str(e)}"
            self.logger.error(error_msg)
            return FileOperationResult(False, error_msg)
    
    def create_backup(self, source_path: Path, backup_name: str = None,
                     incremental: bool = False) -> FileOperationResult:
        """
        創(chuàng)建備份
        
        Args:
            source_path: 源路徑
            backup_name: 備份名稱
            incremental: 是否增量備份
            
        Returns:
            FileOperationResult: 操作結(jié)果
        """
        try:
            if not source_path.exists():
                return FileOperationResult(False, f"源路徑不存在: {source_path}")
            
            backup_path = self.backup_mgr.create_backup(source_path, backup_name, incremental)
            
            if backup_path:
                message = f"備份創(chuàng)建成功: {backup_path}"
                details = {
                    'backup_path': backup_path,
                    'backup_size': backup_path.stat().st_size,
                    'incremental': incremental
                }
                
                self.operation_history.append({
                    'timestamp': datetime.now(),
                    'operation': 'create_backup',
                    'source': source_path,
                    'result': details
                })
                
                return FileOperationResult(True, message, details)
            else:
                return FileOperationResult(False, "備份創(chuàng)建失敗")
            
        except Exception as e:
            error_msg = f"創(chuàng)建備份失敗: {str(e)}"
            self.logger.error(error_msg)
            return FileOperationResult(False, error_msg)
    
    def restore_backup(self, backup_path: Path, target_path: Path,
                      overwrite: bool = False) -> FileOperationResult:
        """
        恢復備份
        
        Args:
            backup_path: 備份路徑
            target_path: 目標路徑
            overwrite: 是否覆蓋
            
        Returns:
            FileOperationResult: 操作結(jié)果
        """
        try:
            success = self.backup_mgr.restore_backup(backup_path, target_path, overwrite)
            
            if success:
                message = f"備份恢復成功: {target_path}"
                details = {
                    'backup_path': backup_path,
                    'target_path': target_path
                }
                
                self.operation_history.append({
                    'timestamp': datetime.now(),
                    'operation': 'restore_backup',
                    'result': details
                })
                
                return FileOperationResult(True, message, details)
            else:
                return FileOperationResult(False, "備份恢復失敗")
            
        except Exception as e:
            error_msg = f"恢復備份失敗: {str(e)}"
            self.logger.error(error_msg)
            return FileOperationResult(False, error_msg)
    
    def cleanup_system(self) -> FileOperationResult:
        """
        清理系統(tǒng)（舊備份等）
        
        Returns:
            FileOperationResult: 操作結(jié)果
        """
        try:
            # 清理舊備份
            deleted_count = self.backup_mgr.cleanup_old_backups()
            
            # 清理臨時文件等（這里可以擴展）
            message = f"系統(tǒng)清理完成: 刪除 {deleted_count} 個舊備份"
            details = {
                'deleted_backups': deleted_count
            }
            
            self.operation_history.append({
                'timestamp': datetime.now(),
                'operation': 'cleanup_system',
                'result': details
            })
            
            return FileOperationResult(True, message, details)
            
        except Exception as e:
            error_msg = f"系統(tǒng)清理失敗: {str(e)}"
            self.logger.error(error_msg)
            return FileOperationResult(False, error_msg)
    
    def get_operation_history(self, limit: int = 10) -> List[Dict]:
        """
        獲取操作歷史
        
        Args:
            limit: 返回記錄數(shù)量限制
            
        Returns:
            List[Dict]: 操作歷史
        """
        return self.operation_history[-limit:]
    
    def generate_report(self) -> Dict:
        """
        生成系統(tǒng)報告
        
        Returns:
            Dict: 系統(tǒng)報告
        """
        report = {
            'timestamp': datetime.now(),
            'operations_count': len(self.operation_history),
            'recent_operations': self.get_operation_history(5),
            'system_status': {
                'backup_enabled': self.config['backup']['enabled'],
                'classification_enabled': self.config['classification']['enabled'],
                'renaming_enabled': self.config['renaming']['enabled']
            }
        }
        
        # 統(tǒng)計各類操作數(shù)量
        op_counts = {}
        for op in self.operation_history:
            op_type = op['operation']
            op_counts[op_type] = op_counts.get(op_type, 0) + 1
        
        report['operation_stats'] = op_counts
        
        return report

def main():
    """主函數(shù) - 演示完整功能"""
    file_mgr = AutomatedFileManager()
    
    print("=== 自動化文件管理系統(tǒng) ===")
    print("請選擇操作:")
    print("1. 整理目錄")
    print("2. 批量重命名")
    print("3. 創(chuàng)建備份")
    print("4. 恢復備份")
    print("5. 系統(tǒng)清理")
    print("6. 查看報告")
    print("7. 退出")
    
    while True:
        choice = input("\n請輸入選擇 (1-7): ").strip()
        
        if choice == '1':
            path = input("請輸入要整理的目錄路徑: ").strip()
            target = input("目標目錄（留空則在原目錄整理）: ").strip()
            dry_run = input("試運行模式？(y/n): ").strip().lower() == 'y'
            
            result = file_mgr.organize_directory(Path(path), 
                                               Path(target) if target else None, 
                                               dry_run)
            print(f"結(jié)果: {result.message}")
        
        elif choice == '2':
            path = input("請輸入目錄路徑: ").strip()
            pattern = input("文件名模式（支持 {number}、{name}、{ext} 等）: ").strip()
            strategy = input("排序策略 (sequential/name/size/creation_time): ").strip()
            dry_run = input("試運行模式？(y/n): ").strip().lower() == 'y'
            
            result = file_mgr.bulk_rename(Path(path), pattern, strategy, dry_run=dry_run)
            print(f"結(jié)果: {result.message}")
        
        elif choice == '3':
            path = input("請輸入要備份的路徑: ").strip()
            name = input("備份名稱（留空則自動生成）: ").strip()
            incremental = input("增量備份？(y/n): ").strip().lower() == 'y'
            
            result = file_mgr.create_backup(Path(path), name or None, incremental)
            print(f"結(jié)果: {result.message}")
        
        elif choice == '4':
            backup_path = input("請輸入備份文件路徑: ").strip()
            target_path = input("恢復目標路徑: ").strip()
            overwrite = input("覆蓋現(xiàn)有文件？(y/n): ").strip().lower() == 'y'
            
            result = file_mgr.restore_backup(Path(backup_path), Path(target_path), overwrite)
            print(f"結(jié)果: {result.message}")
        
        elif choice == '5':
            result = file_mgr.cleanup_system()
            print(f"結(jié)果: {result.message}")
        
        elif choice == '6':
            report = file_mgr.generate_report()
            print("\n=== 系統(tǒng)報告 ===")
            print(f"總操作次數(shù): {report['operations_count']}")
            print("操作統(tǒng)計:")
            for op_type, count in report['operation_stats'].items():
                print(f"  {op_type}: {count} 次")
            print("最近操作:")
            for op in report['recent_operations']:
                print(f"  {op['timestamp']}: {op['operation']}")
        
        elif choice == '7':
            print("謝謝使用！")
            break
        
        else:
            print("無效選擇，請重新輸入。")

if __name__ == "__main__":
    main()