import os
import sys
import argparse
import json
import shutil
import tempfile
from datetime import datetime, timedelta
import platform
import glob

class SystemCleaner:
    def __init__(self):
        self.os_type = platform.system().lower()
        self.cleanup_rules = []
        self.whitelist = set()
        self.cleaned_files = []
        self.cleaned_size = 0
        self.errors = []
        
        # 默認(rèn)清理規(guī)則
        self._set_default_rules()
        
    def _set_default_rules(self):
        """設(shè)置默認(rèn)清理規(guī)則"""
        if self.os_type == 'windows':
            # Windows系統(tǒng)默認(rèn)清理規(guī)則
            self.cleanup_rules.extend([
                {
                    'name': '臨時(shí)文件',
                    'paths': [
                        os.environ.get('TEMP', ''),
                        os.path.join(os.environ.get('SYSTEMROOT', ''), 'Temp'),
                        os.path.expanduser('~\\AppData\\Local\\Temp')
                    ],
                    'patterns': ['*'],
                    'age_days': 7
                },
                {
                    'name': '回收站',
                    'paths': [os.path.join(drive + ':\\', '$Recycle.Bin') for drive in 'CDEFGHIJKLMNOPQRSTUVWXYZ'],
                    'patterns': ['*'],
                    'age_days': 30
                },
                {
                    'name': '瀏覽器緩存',
                    'paths': [
                        os.path.expanduser('~\\AppData\\Local\\Google\\Chrome\\User Data\\Default\\Cache'),
                        os.path.expanduser('~\\AppData\\Local\\Mozilla\\Firefox\\Profiles\\*\\cache2'),
                        os.path.expanduser('~\\AppData\\Local\\Microsoft\\Edge\\User Data\\Default\\Cache')
                    ],
                    'patterns': ['*'],
                    'age_days': 7
                }
            ])
        elif self.os_type == 'linux':
            # Linux系統(tǒng)默認(rèn)清理規(guī)則
            self.cleanup_rules.extend([
                {
                    'name': '臨時(shí)文件',
                    'paths': ['/tmp', '/var/tmp'],
                    'patterns': ['*'],
                    'age_days': 7
                },
                {
                    'name': '用戶緩存',
                    'paths': [os.path.expanduser('~/.cache')],
                    'patterns': ['*'],
                    'age_days': 30
                },
                {
                    'name': '日志文件',
                    'paths': ['/var/log'],
                    'patterns': ['*.log.*', '*.gz'],
                    'age_days': 30
                }
            ])
        elif self.os_type == 'darwin':  # macOS
            # macOS系統(tǒng)默認(rèn)清理規(guī)則
            self.cleanup_rules.extend([
                {
                    'name': '臨時(shí)文件',
                    'paths': ['/tmp', '/var/tmp'],
                    'patterns': ['*'],
                    'age_days': 7
                },
                {
                    'name': '用戶緩存',
                    'paths': [os.path.expanduser('~/Library/Caches')],
                    'patterns': ['*'],
                    'age_days': 30
                },
                {
                    'name': '日志文件',
                    'paths': [os.path.expanduser('~/Library/Logs')],
                    'patterns': ['*.log.*'],
                    'age_days': 30
                }
            ])
            
    def add_whitelist(self, paths):
        """添加白名單路徑"""
        if isinstance(paths, str):
            paths = [paths]
        for path in paths:
            self.whitelist.add(os.path.abspath(path))
            
    def load_config(self, config_file):
        """從配置文件加載清理規(guī)則"""
        try:
            with open(config_file, 'r', encoding='utf-8') as f:
                config = json.load(f)
                
            # 加載清理規(guī)則
            if 'cleanup_rules' in config:
                self.cleanup_rules = config['cleanup_rules']
                
            # 加載白名單
            if 'whitelist' in config:
                self.add_whitelist(config['whitelist'])
                
            return True
        except Exception as e:
            self.errors.append(f"加載配置文件失敗: {e}")
            return False
            
    def save_config(self, config_file):
        """保存配置到文件"""
        try:
            config = {
                'cleanup_rules': self.cleanup_rules,
                'whitelist': list(self.whitelist)
            }
            
            with open(config_file, 'w', encoding='utf-8') as f:
                json.dump(config, f, indent=2, ensure_ascii=False)
                
            return True
        except Exception as e:
            self.errors.append(f"保存配置文件失敗: {e}")
            return False
            
    def format_bytes(self, bytes_value):
        """格式化字節(jié)單位"""
        for unit in ['B', 'KB', 'MB', 'GB', 'TB']:
            if bytes_value < 1024.0:
                return f"{bytes_value:.2f} {unit}"
            bytes_value /= 1024.0
        return f"{bytes_value:.2f} PB"
        
    def is_safe_path(self, path):
        """檢查路徑是否安全"""
        # 檢查是否在白名單中
        abs_path = os.path.abspath(path)
        for whitelist_path in self.whitelist:
            if abs_path.startswith(whitelist_path):
                return False
                
        # 檢查是否是系統(tǒng)關(guān)鍵目錄
        critical_paths = []
        if self.os_type == 'windows':
            system_root = os.environ.get('SYSTEMROOT', 'C:\\Windows')
            critical_paths = [system_root, 'C:\\Program Files', 'C:\\Program Files (x86)']
        elif self.os_type in ['linux', 'darwin']:
            critical_paths = ['/bin', '/sbin', '/usr/bin', '/usr/sbin', '/etc', '/boot']
            
        for critical_path in critical_paths:
            if abs_path.startswith(critical_path):
                return False
                
        return True
        
    def get_file_age(self, filepath):
        """獲取文件年齡（天數(shù)）"""
        try:
            file_time = os.path.getmtime(filepath)
            file_datetime = datetime.fromtimestamp(file_time)
            age = datetime.now() - file_datetime
            return age.days
        except:
            return 0
            
    def match_patterns(self, filename, patterns):
        """檢查文件名是否匹配模式"""
        for pattern in patterns:
            if glob.fnmatch.fnmatch(filename, pattern):
                return True
        return False
        
    def scan_files(self, rule):
        """掃描符合規(guī)則的文件"""
        found_files = []
        
        for path in rule['paths']:
            if not path or not os.path.exists(path):
                continue
                
            try:
                # 遞歸遍歷目錄
                for root, dirs, files in os.walk(path):
                    # 跳過隱藏目錄
                    dirs[:] = [d for d in dirs if not d.startswith('.')]
                    
                    for filename in files:
                        # 跳過隱藏文件
                        if filename.startswith('.'):
                            continue
                            
                        filepath = os.path.join(root, filename)
                        
                        # 檢查文件是否匹配模式
                        if not self.match_patterns(filename, rule['patterns']):
                            continue
                            
                        # 檢查文件年齡
                        if 'age_days' in rule:
                            file_age = self.get_file_age(filepath)
                            if file_age < rule['age_days']:
                                continue
                                
                        # 檢查路徑安全性
                        if not self.is_safe_path(filepath):
                            continue
                            
                        # 獲取文件大小
                        try:
                            file_size = os.path.getsize(filepath)
                        except:
                            file_size = 0
                            
                        found_files.append({
                            'path': filepath,
                            'size': file_size,
                            'age': self.get_file_age(filepath)
                        })
                        
            except Exception as e:
                self.errors.append(f"掃描目錄 {path} 時(shí)出錯(cuò): {e}")
                
        return found_files
        
    def preview_cleanup(self):
        """預(yù)覽清理操作"""
        print("系統(tǒng)清理預(yù)覽")
        print("=" * 60)
        print(f"操作系統(tǒng): {self.os_type}")
        print()
        
        total_files = 0
        total_size = 0
        
        for rule in self.cleanup_rules:
            print(f"清理規(guī)則: {rule['name']}")
            files = self.scan_files(rule)
            
            if files:
                rule_size = sum(f['size'] for f in files)
                print(f"  發(fā)現(xiàn)文件: {len(files)} 個(gè)")
                print(f"  預(yù)計(jì)釋放: {self.format_bytes(rule_size)}")
                total_files += len(files)
                total_size += rule_size
                
                # 顯示前10個(gè)文件作為示例
                print("  文件示例:")
                for i, file_info in enumerate(files[:10]):
                    print(f"    {file_info['path']} ({self.format_bytes(file_info['size'])}, {file_info['age']}天)")
                if len(files) > 10:
                    print(f"    ... 還有 {len(files) - 10} 個(gè)文件")
            else:
                print("  未發(fā)現(xiàn)符合條件的文件")
            print()
            
        print(f"總計(jì):")
        print(f"  文件數(shù)量: {total_files}")
        print(f"  預(yù)計(jì)釋放: {self.format_bytes(total_size)}")
        
        return total_files, total_size
        
    def perform_cleanup(self, dry_run=True):
        """執(zhí)行清理操作"""
        print(f"{'預(yù)覽' if dry_run else '執(zhí)行'}系統(tǒng)清理")
        print("=" * 60)
        
        self.cleaned_files = []
        self.cleaned_size = 0
        cleaned_count = 0
        
        for rule in self.cleanup_rules:
            print(f"處理規(guī)則: {rule['name']}")
            files = self.scan_files(rule)
            
            for file_info in files:
                filepath = file_info['path']
                filesize = file_info['size']
                
                if dry_run:
                    print(f"  將刪除: {filepath} ({self.format_bytes(filesize)})")
                else:
                    try:
                        os.remove(filepath)
                        print(f"  已刪除: {filepath}")
                        self.cleaned_files.append(filepath)
                        self.cleaned_size += filesize
                        cleaned_count += 1
                    except Exception as e:
                        error_msg = f"刪除文件 {filepath} 失敗: {e}"
                        print(f"  錯(cuò)誤: {error_msg}")
                        self.errors.append(error_msg)
                        
            print()
            
        if not dry_run:
            print(f"清理完成:")
            print(f"  刪除文件: {cleaned_count} 個(gè)")
            print(f"  釋放空間: {self.format_bytes(self.cleaned_size)}")
            
        return cleaned_count, self.cleaned_size
        
    def clean_empty_dirs(self, dry_run=True):
        """清理空目錄"""
        print(f"{'預(yù)覽' if dry_run else '執(zhí)行'}空目錄清理")
        print("=" * 60)
        
        cleaned_dirs = 0
        
        for rule in self.cleanup_rules:
            for path in rule['paths']:
                if not path or not os.path.exists(path):
                    continue
                    
                try:
                    for root, dirs, files in os.walk(path, topdown=False):
                        # 檢查目錄是否為空
                        if not os.listdir(root):
                            if dry_run:
                                print(f"  將刪除空目錄: {root}")
                            else:
                                try:
                                    os.rmdir(root)
                                    print(f"  已刪除空目錄: {root}")
                                    cleaned_dirs += 1
                                except Exception as e:
                                    error_msg = f"刪除目錄 {root} 失敗: {e}"
                                    print(f"  錯(cuò)誤: {error_msg}")
                                    self.errors.append(error_msg)
                except Exception as e:
                    self.errors.append(f"遍歷目錄 {path} 時(shí)出錯(cuò): {e}")
                    
        if not dry_run:
            print(f"空目錄清理完成: {cleaned_dirs} 個(gè)目錄")
            
        return cleaned_dirs
        
    def generate_report(self):
        """生成清理報(bào)告"""
        report = []
        report.append("=" * 80)
        report.append("系統(tǒng)清理報(bào)告")
        report.append("=" * 80)
        report.append(f"清理時(shí)間: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
        report.append(f"操作系統(tǒng): {self.os_type}")
        report.append("")
        
        # 清理統(tǒng)計(jì)
        report.append("清理統(tǒng)計(jì):")
        report.append(f"  刪除文件: {len(self.cleaned_files)} 個(gè)")
        report.append(f"  釋放空間: {self.format_bytes(self.cleaned_size)}")
        report.append("")
        
        # 清理的文件列表
        if self.cleaned_files:
            report.append("已清理的文件:")
            report.append("-" * 50)
            for filepath in self.cleaned_files:
                report.append(f"  {filepath}")
            report.append("")
            
        # 錯(cuò)誤信息
        if self.errors:
            report.append("錯(cuò)誤信息:")
            report.append("-" * 50)
            for error in self.errors[:20]:  # 只顯示前20個(gè)錯(cuò)誤
                report.append(f"  {error}")
            if len(self.errors) > 20:
                report.append(f"  ... 還有 {len(self.errors) - 20} 個(gè)錯(cuò)誤")
            report.append("")
            
        report.append("=" * 80)
        return "\n".join(report)
        
    def save_report(self, filename):
        """保存報(bào)告到文件"""
        try:
            report = self.generate_report()
            with open(filename, 'w', encoding='utf-8') as f:
                f.write(report)
            print(f"報(bào)告已保存到: {filename}")
            return True
        except Exception as e:
            print(f"保存報(bào)告時(shí)出錯(cuò): {e}")
            return False

def create_sample_config():
    """創(chuàng)建示例配置文件"""
    config = {
        "cleanup_rules": [
            {
                "name": "自定義臨時(shí)文件",
                "paths": ["/custom/temp/path"],
                "patterns": ["*.tmp", "*.temp"],
                "age_days": 7
            }
        ],
        "whitelist": [
            "/important/files/not/to/delete"
        ]
    }
    
    try:
        with open('cleaner_config.json', 'w', encoding='utf-8') as f:
            json.dump(config, f, indent=2, ensure_ascii=False)
        print("示例配置文件已創(chuàng)建: cleaner_config.json")
        return True
    except Exception as e:
        print(f"創(chuàng)建示例配置文件時(shí)出錯(cuò): {e}")
        return False

def main():
    parser = argparse.ArgumentParser(description="系統(tǒng)清理工具")
    parser.add_argument("-c", "--config", help="配置文件路徑")
    parser.add_argument("-p", "--preview", action="store_true", help="預(yù)覽模式，不實(shí)際刪除文件")
    parser.add_argument("-o", "--output", help="保存報(bào)告到文件")
    parser.add_argument("--create-config", action="store_true", help="創(chuàng)建示例配置文件")
    parser.add_argument("--clean-empty-dirs", action="store_true", help="清理空目錄")
    parser.add_argument("--add-whitelist", action="append", help="添加白名單路徑")
    
    args = parser.parse_args()
    
    # 創(chuàng)建示例配置文件
    if args.create_config:
        create_sample_config()
        return
        
    try:
        cleaner = SystemCleaner()
        
        # 加載配置文件
        if args.config:
            if not cleaner.load_config(args.config):
                print("加載配置文件失敗")
                sys.exit(1)
                
        # 添加白名單
        if args.add_whitelist:
            cleaner.add_whitelist(args.add_whitelist)
            
        # 預(yù)覽或執(zhí)行清理
        if args.preview:
            cleaner.preview_cleanup()
        else:
            # 執(zhí)行清理
            cleaned_count, cleaned_size = cleaner.perform_cleanup(dry_run=False)
            
            # 清理空目錄
            if args.clean_empty_dirs:
                cleaner.clean_empty_dirs(dry_run=False)
                
            # 生成報(bào)告
            if args.output:
                cleaner.save_report(args.output)
            else:
                print(cleaner.generate_report())
                
    except KeyboardInterrupt:
        print("\n\n用戶中斷操作")
    except Exception as e:
        print(f"程序執(zhí)行出錯(cuò): {e}")
        sys.exit(1)

if __name__ == "__main__":
    main()

# 創(chuàng)建示例配置文件
python system_cleaner.py --create-config

# 預(yù)覽清理操作（不實(shí)際刪除文件）
python system_cleaner.py --preview

# 執(zhí)行清理操作
python system_cleaner.py

# 使用配置文件
python system_cleaner.py -c cleaner_config.json

# 保存清理報(bào)告
python system_cleaner.py -o cleanup_report.txt

# 清理空目錄
python system_cleaner.py --clean-empty-dirs

# 添加白名單路徑
python system_cleaner.py --add-whitelist /important/data --preview

{
  "cleanup_rules": [
    {
      "name": "自定義臨時(shí)文件",
      "paths": ["/custom/temp/path"],
      "patterns": ["*.tmp", "*.temp"],
      "age_days": 7
    }
  ],
  "whitelist": [
    "/important/files/not/to/delete"
  ]
}

python system_cleaner.py --preview

python system_cleaner.py -o cleanup_$(date +%Y%m%d).txt

python system_cleaner.py -c my_cleaner_config.json --preview

python system_cleaner.py --add-whitelist /home/user/important --clean-empty-dirs