import sys
import platform

def analyze_system_encoding():
    """分析當(dāng)前系統(tǒng)的文件名編碼情況"""
    print(f"操作系統(tǒng): {platform.system()} {platform.release()}")
    print(f"Python版本: {sys.version}")
    print(f"默認(rèn)文件系統(tǒng)編碼: {sys.getfilesystemencoding()}")
    print(f"默認(rèn)字符串編碼: {sys.getdefaultencoding()}")
    
    # 檢查平臺特定信息
    if platform.system() == "Windows":
        import locale
        print(f"Windows ANSI代碼頁: {locale.getpreferredencoding()}")
    elif platform.system() == "Linux":
        # 在Linux上檢查LANG環(huán)境變量
        lang = os.environ.get('LANG', '未設(shè)置')
        print(f"LANG環(huán)境變量: {lang}")

# 運行分析
analyze_system_encoding()

import os
import sys

def file_operations_with_bytes(path_bytes):
    """
    使用字節(jié)路徑進(jìn)行文件操作
    """
    try:
        # 檢查文件是否存在
        if os.path.exists(path_bytes):
            print("文件存在")
            
            # 獲取文件狀態(tài)
            stat_info = os.stat(path_bytes)
            print(f"文件大小: {stat_info.st_size} 字節(jié)")
            
            # 讀取文件內(nèi)容
            with open(path_bytes, 'rb') as f:
                content = f.read(100)  # 讀取前100字節(jié)
                print(f"文件開頭: {content[:20]}...")
                
            return True
        else:
            print("文件不存在")
            return False
            
    except Exception as e:
        print(f"文件操作失敗: {e}")
        return False

# 示例：處理可能包含特殊字符的文件名
def handle_problematic_filename():
    # 假設(shè)我們有一個可能編碼有問題的文件名
    original_path = "中文文件.txt"  # 可能在某些環(huán)境下編碼錯誤
    
    try:
        # 嘗試轉(zhuǎn)換為字節(jié)
        if isinstance(original_path, str):
            # 使用文件系統(tǒng)編碼轉(zhuǎn)換為字節(jié)
            byte_path = original_path.encode(sys.getfilesystemencoding())
        else:
            byte_path = original_path
            
        # 使用字節(jié)路徑進(jìn)行操作
        success = file_operations_with_bytes(byte_path)
        return success
        
    except UnicodeEncodeError as e:
        print(f"編碼失敗: {e}")
        return False

# 使用示例
handle_problematic_filename()

import os
import sys

def list_directory_bytes(directory_path):
    """
    使用字節(jié)路徑列出目錄內(nèi)容
    """
    try:
        # 確保路徑是字節(jié)格式
        if isinstance(directory_path, str):
            directory_bytes = directory_path.encode(sys.getfilesystemencoding())
        else:
            directory_bytes = directory_path
        
        # 使用os.listdir的字節(jié)版本
        with os.scandir(directory_bytes) as entries:
            for entry in entries:
                # entry.name 在Python 3.5+中是字符串，但我們可以獲取原始字節(jié)信息
                print(f"條目: {entry.name}")
                
                # 對于需要原始字節(jié)的場景，可以這樣處理
                try:
                    # 嘗試以字符串方式處理
                    if entry.is_file():
                        print(f"  類型: 文件")
                    elif entry.is_dir():
                        print(f"  類型: 目錄")
                except UnicodeError:
                    # 如果字符串處理失敗，使用字節(jié)方式
                    print(f"  類型: 未知（編碼問題）")
                    # 這里可以使用entry.path獲取字節(jié)路徑進(jìn)行進(jìn)一步操作
                    
    except FileNotFoundError:
        print("目錄不存在")
    except PermissionError:
        print("沒有訪問權(quán)限")
    except Exception as e:
        print(f"列出目錄時出錯: {e}")

# 使用示例
list_directory_bytes("/path/to/directory")

import chardet
from pathlib import Path

class SmartFilenameDecoder:
    """
    智能文件名解碼器
    """
    
    def __init__(self):
        self.common_encodings = ['utf-8', 'gbk', 'gb2312', 'shift_jis', 
                               'iso-8859-1', 'windows-1252']
    
    def detect_filename_encoding(self, byte_sequence):
        """
        檢測字節(jié)序列的編碼
        """
        # 首先嘗試常見編碼
        for encoding in self.common_encodings:
            try:
                decoded = byte_sequence.decode(encoding)
                # 簡單的有效性檢查：是否包含可打印字符
                if any(c.isprintable() or c.isspace() for c in decoded):
                    return encoding, decoded
            except UnicodeDecodeError:
                continue
        
        # 使用chardet進(jìn)行智能檢測
        try:
            result = chardet.detect(byte_sequence)
            if result['confidence'] > 0.7:  # 置信度閾值
                encoding = result['encoding']
                decoded = byte_sequence.decode(encoding)
                return encoding, decoded
        except:
            pass
        
        # 最后嘗試：使用替換錯誤處理
        try:
            decoded = byte_sequence.decode('utf-8', errors='replace')
            return 'utf-8-with-replace', decoded
        except:
            return None, None
    
    def safe_path_conversion(self, raw_path):
        """
        安全路徑轉(zhuǎn)換
        """
        if isinstance(raw_path, bytes):
            encoding, decoded = self.detect_filename_encoding(raw_path)
            if decoded:
                return decoded
            else:
                # 無法解碼，返回可讀的字節(jié)表示
                return f"byte_{raw_path.hex()[:16]}..."
        else:
            return raw_path

# 使用示例
decoder = SmartFilenameDecoder()

# 測試各種編碼
test_bytes = [
    "中文文件.txt".encode('gbk'),
    "日本語ファイル.txt".encode('shift_jis'),
    "file with spécial chars.txt".encode('utf-8'),
    b'\xff\xfe\x00\x00'  # 無效字節(jié)序列
]

for i, byte_data in enumerate(test_bytes):
    encoding, decoded = decoder.detect_filename_encoding(byte_data)
    print(f"測試 {i+1}: 編碼={encoding}, 解碼結(jié)果={decoded}")

import os
from pathlib import Path

class MixedEncodingHandler:
    """
    處理混合編碼目錄的工具類
    """
    
    def __init__(self):
        self.decoder = SmartFilenameDecoder()
    
    def walk_mixed_encoding(self, root_dir):
        """
        遍歷可能包含混合編碼的目錄
        """
        root_path = Path(root_dir)
        
        try:
            with os.scandir(root_dir) as entries:
                for entry in entries:
                    try:
                        # 嘗試正常處理
                        entry_name = entry.name
                        entry_path = entry.path
                        
                        if entry.is_file():
                            print(f"文件: {entry_name}")
                        elif entry.is_dir():
                            print(f"目錄: {entry_name}/")
                            # 遞歸遍歷子目錄
                            self.walk_mixed_encoding(entry_path)
                            
                    except UnicodeError:
                        # 遇到編碼問題，使用字節(jié)方式處理
                        print("遇到編碼問題，使用字節(jié)方式處理...")
                        self._handle_encoding_problem(entry)
                        
        except Exception as e:
            print(f"遍歷目錄時出錯: {e}")
    
    def _handle_encoding_problem(self, entry):
        """
        處理編碼有問題的目錄條目
        """
        try:
            # 獲取原始字節(jié)信息（通過路徑）
            byte_path = getattr(entry, '_name_bytes', None)
            if byte_path is None:
                # 對于某些系統(tǒng)，可能需要其他方式獲取字節(jié)名稱
                byte_path = entry.path.encode('latin-1', errors='replace')
            
            # 嘗試解碼
            decoded_name = self.decoder.safe_path_conversion(byte_path)
            
            # 獲取文件類型
            try:
                if entry.is_file():
                    file_type = "文件"
                elif entry.is_dir():
                    file_type = "目錄"
                else:
                    file_type = "其他"
            except:
                file_type = "未知"
            
            print(f"{file_type} (編碼問題): {decoded_name}")
            
        except Exception as e:
            print(f"處理編碼問題時出錯: {e}")

# 使用示例
handler = MixedEncodingHandler()
handler.walk_mixed_encoding("/path/to/problematic/directory")

import os
import shutil
from pathlib import Path

class EncodingAwareFileSync:
    """
    支持編碼處理的文件同步工具
    """
    
    def __init__(self, source_dir, target_dir):
        self.source_dir = Path(source_dir)
        self.target_dir = Path(target_dir)
        self.decoder = SmartFilenameDecoder()
    
    def sync_files(self):
        """
        同步文件，處理編碼問題
        """
        if not self.source_dir.exists():
            print("源目錄不存在")
            return False
        
        # 確保目標(biāo)目錄存在
        self.target_dir.mkdir(parents=True, exist_ok=True)
        
        # 遍歷源目錄
        for root, dirs, files in os.walk(self.source_dir):
            # 處理相對路徑
            rel_path = Path(root).relative_to(self.source_dir)
            
            # 創(chuàng)建對應(yīng)的目標(biāo)目錄
            target_root = self.target_dir / rel_path
            target_root.mkdir(exist_ok=True)
            
            # 處理文件
            for file in files:
                source_file = Path(root) / file
                target_file = target_root / file
                
                self._sync_single_file(source_file, target_file)
        
        return True
    
    def _sync_single_file(self, source_file, target_file):
        """
        同步單個文件
        """
        try:
            # 正常情況下的同步
            if not target_file.exists() or \
               source_file.stat().st_mtime > target_file.stat().st_mtime:
                shutil.copy2(source_file, target_file)
                print(f"同步: {source_file} -> {target_file}")
                
        except UnicodeError:
            # 處理編碼問題
            self._handle_encoding_sync(source_file, target_file)
        except Exception as e:
            print(f"同步文件時出錯: {source_file} - {e}")
    
    def _handle_encoding_sync(self, source_file, target_file):
        """
        處理編碼有問題的文件同步
        """
        try:
            # 獲取字節(jié)路徑
            source_bytes = str(source_file).encode('latin-1', errors='replace')
            target_bytes = str(target_file).encode('latin-1', errors='replace')
            
            # 使用字節(jié)路徑操作
            with open(source_bytes, 'rb') as src:
                content = src.read()
                
            with open(target_bytes, 'wb') as dst:
                dst.write(content)
            
            # 復(fù)制元數(shù)據(jù)
            stat = os.stat(source_bytes)
            os.utime(target_bytes, (stat.st_atime, stat.st_mtime))
            
            decoded_name = self.decoder.safe_path_conversion(source_bytes)
            print(f"同步（編碼處理）: {decoded_name}")
            
        except Exception as e:
            print(f"處理編碼同步時出錯: {e}")

# 使用示例
sync_tool = EncodingAwareFileSync("/source/directory", "/target/directory")
sync_tool.sync_files()

import os
import re
from pathlib import Path

class FilenameEncodingFixer:
    """
    文件名編碼修復(fù)工具
    """
    
    def __init__(self):
        self.decoder = SmartFilenameDecoder()
        self.encoding_stats = {}
    
    def fix_directory_encodings(self, directory_path, dry_run=True):
        """
        修復(fù)目錄中的文件名編碼問題
        """
        dir_path = Path(directory_path)
        if not dir_path.exists() or not dir_path.is_dir():
            print("目錄不存在或不是目錄")
            return False
        
        fixed_count = 0
        problem_count = 0
        
        # 遍歷目錄
        for item in dir_path.iterdir():
            original_name = item.name
            original_path = item
            
            try:
                # 測試文件名是否可正常處理
                test = str(original_name)
                
                # 如果正常，跳過
                if self._is_valid_filename(original_name):
                    continue
                    
            except UnicodeError:
                # 發(fā)現(xiàn)編碼問題
                problem_count += 1
                
                if not dry_run:
                    # 嘗試修復(fù)
                    success = self._fix_single_filename(original_path)
                    if success:
                        fixed_count += 1
                else:
                    print(f"發(fā)現(xiàn)編碼問題: {original_name}")
        
        print(f"發(fā)現(xiàn) {problem_count} 個編碼問題，修復(fù) {fixed_count} 個")
        return True
    
    def _is_valid_filename(self, filename):
        """
        檢查文件名是否有效
        """
        try:
            # 嘗試編碼和解碼
            encoded = filename.encode('utf-8')
            decoded = encoded.decode('utf-8')
            
            # 檢查是否包含非法字符（根據(jù)操作系統(tǒng)）
            if os.name == 'nt':  # Windows
                invalid_chars = r'[<>:"/\\|?*]'
            else:  # Unix/Linux
                invalid_chars = r'[/]'
            
            if re.search(invalid_chars, filename):
                return False
                
            return True
            
        except UnicodeError:
            return False
    
    def _fix_single_filename(self, file_path):
        """
        修復(fù)單個文件名
        """
        try:
            # 獲取原始字節(jié)名稱
            original_bytes = str(file_path).encode('latin-1', errors='replace')
            
            # 嘗試檢測正確編碼
            encoding, decoded_name = self.decoder.detect_filename_encoding(original_bytes)
            
            if not decoded_name:
                print(f"無法修復(fù): {file_path}")
                return False
            
            # 生成新路徑
            parent_dir = file_path.parent
            new_path = parent_dir / decoded_name
            
            # 避免名稱沖突
            counter = 1
            while new_path.exists():
                stem = file_path.stem
                suffix = file_path.suffix
                new_name = f"{stem}_{counter}{suffix}"
                new_path = parent_dir / new_name
                counter += 1
            
            # 重命名文件
            file_path.rename(new_path)
            print(f"修復(fù): {file_path.name} -> {new_path.name}")
            return True
            
        except Exception as e:
            print(f"修復(fù)文件名時出錯: {file_path} - {e}")
            return False

# 使用示例
fixer = FilenameEncodingFixer()

# 先進(jìn)行干運行（不實際修改）
fixer.fix_directory_encodings("/path/to/fix", dry_run=True)

# 實際修復(fù)
fixer.fix_directory_encodings("/path/to/fix", dry_run=False)

import os
import sys
from pathlib import Path

class CrossPlatformFilenameHandler:
    """
    跨平臺文件名處理框架
    """
    
    def __init__(self):
        self.system_encoding = sys.getfilesystemencoding()
        self.is_windows = os.name == 'nt'
    
    def normalize_filename(self, filename):
        """
        規(guī)范化文件名，確保跨平臺兼容
        """
        if isinstance(filename, bytes):
            # 字節(jié)文件名，需要解碼
            try:
                decoded = filename.decode(self.system_encoding)
                return self._sanitize_filename(decoded)
            except UnicodeDecodeError:
                # 解碼失敗，使用安全轉(zhuǎn)換
                return self._safe_byte_conversion(filename)
        else:
            # 字符串文件名，進(jìn)行清理
            return self._sanitize_filename(filename)
    
    def _sanitize_filename(self, filename):
        """
        清理文件名，移除非法字符
        """
        # 定義非法字符（根據(jù)操作系統(tǒng)）
        if self.is_windows:
            invalid_chars = r'[<>:"/\\|?*]'
            max_length = 255  # Windows文件名長度限制
        else:
            invalid_chars = r'[/]'
            max_length = 255  # 一般Unix限制
        
        # 移除非法字符
        import re
        sanitized = re.sub(invalid_chars, '_', filename)
        
        # 處理保留名稱（Windows）
        if self.is_windows:
            reserved_names = {'CON', 'PRN', 'AUX', 'NUL', 
                             'COM1', 'COM2', 'COM3', 'COM4', 'COM5',
                             'COM6', 'COM7', 'COM8', 'COM9',
                             'LPT1', 'LPT2', 'LPT3', 'LPT4', 'LPT5',
                             'LPT6', 'LPT7', 'LPT8', 'LPT9'}
            if sanitized.upper() in reserved_names:
                sanitized = f"_{sanitized}"
        
        # 截斷過長文件名
        if len(sanitized) > max_length:
            stem = Path(sanitized).stem
            suffix = Path(sanitized).suffix
            # 保留后綴，截斷主干
            if len(suffix) < max_length:
                stem_max = max_length - len(suffix)
                sanitized = stem[:stem_max] + suffix
            else:
                sanitized = sanitized[:max_length]
        
        return sanitized
    
    def _safe_byte_conversion(self, byte_filename):
        """
        安全轉(zhuǎn)換字節(jié)文件名
        """
        try:
            # 嘗試常見編碼
            for encoding in ['utf-8', 'gbk', 'iso-8859-1']:
                try:
                    decoded = byte_filename.decode(encoding)
                    return self._sanitize_filename(decoded)
                except UnicodeDecodeError:
                    continue
            
            # 所有編碼都失敗，使用十六進(jìn)制表示
            hex_str = byte_filename.hex()[:16]
            return f"unknown_{hex_str}"
            
        except Exception:
            return "invalid_filename"
    
    def create_cross_platform_path(self, *path_parts):
        """
        創(chuàng)建跨平臺兼容的路徑
        """
        normalized_parts = []
        
        for part in path_parts:
            if isinstance(part, Path):
                part = str(part)
            
            normalized = self.normalize_filename(part)
            normalized_parts.append(normalized)
        
        # 使用pathlib構(gòu)建路徑
        path = Path(normalized_parts[0])
        for part in normalized_parts[1:]:
            path = path / part
        
        return path

# 使用示例
filename_handler = CrossPlatformFilenameHandler()

# 測試各種文件名
test_names = [
    "正常文件.txt",
    "file with spaces.doc",
    "包含/非法/字符.txt",  # Unix非法
    "包含:非法字符.txt",   # Windows非法
    b'\xff\xfeinvalid bytes'.hex()  # 無效字節(jié)
]

for name in test_names:
    normalized = filename_handler.normalize_filename(name)
    print(f"原始: {name} -> 規(guī)范化: {normalized}")

import time
from functools import wraps

def timing_decorator(func):
    """執(zhí)行時間測量裝飾器"""
    @wraps(func)
    def wrapper(*args, **kwargs):
        start_time = time.time()
        result = func(*args, **kwargs)
        end_time = time.time()
        print(f"{func.__name__} 執(zhí)行時間: {end_time - start_time:.4f}秒")
        return result
    return wrapper

class OptimizedEncodingHandler(CrossPlatformFilenameHandler):
    """
    優(yōu)化的編碼處理器，平衡性能與可靠性
    """
    
    def __init__(self):
        super().__init__()
        self.encoding_cache = {}  # 編碼檢測緩存
    
    @timing_decorator
    def batch_process_files(self, file_list):
        """
        批量處理文件列表
        """
        results = []
        for file_path in file_list:
            try:
                # 使用緩存優(yōu)化重復(fù)文件的處理
                if file_path in self.encoding_cache:
                    result = self.encoding_cache[file_path]
                else:
                    result = self.normalize_filename(file_path)
                    self.encoding_cache[file_path] = result
                
                results.append(result)
            except Exception as e:
                results.append(f"error:{e}")
        
        return results

# 使用示例
optimized_handler = OptimizedEncodingHandler()

# 生成測試文件列表
test_files = ["測試文件.txt"] * 1000 + ["another_file.pdf"] * 500

# 批量處理
results = optimized_handler.batch_process_files(test_files)
print(f"處理 {len(results)} 個文件")