import io
 
def demonstrate_io_layers():
    """
    演示Python的IO層次結(jié)構(gòu)
    """
    # 創(chuàng)建一個示例文件
    with open('test_file.txt', 'w', encoding='utf-8') as f:
        f.write('Hello, 世界!')
    
    # 不同層次的打開方式
    print("=== Python IO層次結(jié)構(gòu)演示 ===")
    
    # 1. 二進制層 - 最底層
    with open('test_file.txt', 'rb') as bin_file:
        print(f"二進制層: {type(bin_file)}")
        raw_data = bin_file.read()
        print(f"原始字節(jié): {raw_data}")
    
    # 2. 文本層 - 帶編碼的文本處理
    with open('test_file.txt', 'r', encoding='utf-8') as text_file:
        print(f"文本層: {type(text_file)}")
        text_data = text_file.read()
        print(f"解碼文本: {text_data}")
    
    # 3. 緩沖層 - 自動處理的緩沖IO
    with io.open('test_file.txt', 'r', encoding='utf-8') as buffered_file:
        print(f"緩沖IO層: {type(buffered_file)}")
    
    # 清理
    import os
    os.remove('test_file.txt')
 
# 運行演示
demonstrate_io_layers()

def common_encoding_scenarios():
    """
    常見的文件編碼問題場景
    """
    scenarios = [
        {
            'name': 'UTF-8文件無BOM',
            'content': 'Hello, 世界!',
            'encoding': 'utf-8',
            'bom': False
        },
        {
            'name': 'UTF-8文件帶BOM',
            'content': 'Hello, 世界!',
            'encoding': 'utf-8-sig',
            'bom': True
        },
        {
            'name': 'GBK中文文件',
            'content': '你好，世界!',
            'encoding': 'gbk',
            'bom': False
        },
        {
            'name': 'Shift-JIS日文文件',
            'content': 'こんにちは、世界!',
            'encoding': 'shift_jis',
            'bom': False
        },
        {
            'name': '混合編碼問題',
            'content': 'Hello, 世界!',
            'encoding': 'iso-8859-1',  # 錯誤的編碼
            'bom': False
        }
    ]
    
    print("=== 常見編碼場景 ===")
    for scenario in scenarios:
        # 創(chuàng)建測試文件
        filename = f"test_{scenario['name']}.txt"
        with open(filename, 'w', encoding=scenario['encoding']) as f:
            if scenario['bom']:
                # 寫入BOM（如果適用）
                f.write('\ufeff')
            f.write(scenario['content'])
        
        # 嘗試用不同編碼讀取
        try:
            with open(filename, 'r', encoding='utf-8') as f:
                content = f.read()
            status = 'UTF-8讀取成功'
        except UnicodeDecodeError:
            status = 'UTF-8讀取失敗'
        
        print(f"{scenario['name']:20} {scenario['encoding']:12} -> {status}")
        
        # 清理
        import os
        os.remove(filename)
 
common_encoding_scenarios()

import io
 
def demonstrate_text_iowrapper():
    """
    演示使用io.TextIOWrapper動態(tài)修改編碼
    """
    # 創(chuàng)建測試文件
    with open('demo_file.txt', 'w', encoding='gbk') as f:
        f.write('中文內(nèi)容測試')
    
    print("=== io.TextIOWrapper 演示 ===")
    
    # 1. 以二進制模式打開文件
    with open('demo_file.txt', 'rb') as binary_file:
        print(f"二進制文件對象: {type(binary_file)}")
        
        # 2. 使用TextIOWrapper添加編碼
        text_wrapper = io.TextIOWrapper(
            binary_file,
            encoding='gbk',  # 正確編碼
            line_buffering=True
        )
        
        print(f"包裝后文本對象: {type(text_wrapper)}")
        content = text_wrapper.read()
        print(f"讀取內(nèi)容: {content}")
        
        # 重要：使用后分離包裝器，避免重復(fù)關(guān)閉
        text_wrapper.detach()
    
    # 3. 動態(tài)重新編碼示例
    with open('demo_file.txt', 'rb') as binary_file:
        # 第一次用GBK讀取
        wrapper_gbk = io.TextIOWrapper(binary_file, encoding='gbk')
        content_gbk = wrapper_gbk.read()
        print(f"GBK讀取: {content_gbk}")
        
        # 分離后重新包裝
        wrapper_gbk.detach()
        binary_file.seek(0)  # 重置文件指針
        
        # 用UTF-8重新包裝（雖然內(nèi)容不對，但演示功能）
        wrapper_utf8 = io.TextIOWrapper(binary_file, encoding='utf-8')
        try:
            content_utf8 = wrapper_utf8.read()
            print(f"UTF-8讀取: {content_utf8}")
        except UnicodeDecodeError as e:
            print(f"UTF-8讀取失敗: {e}")
        finally:
            wrapper_utf8.detach()
    
    # 清理
    import os
    os.remove('demo_file.txt')
 
demonstrate_text_iowrapper()

import chardet
from pathlib import Path
 
class DynamicEncodingAdapter:
    """
    動態(tài)編碼檢測與適配器
    """
    
    def __init__(self):
        self.common_encodings = [
            'utf-8', 'gbk', 'gb2312', 'shift_jis',
            'euc-jp', 'iso-8859-1', 'windows-1252'
        ]
    
    def detect_encoding(self, file_path, sample_size=1024):
        """
        檢測文件編碼
        """
        with open(file_path, 'rb') as f:
            # 讀取樣本數(shù)據(jù)
            raw_data = f.read(sample_size)
            
            # 使用chardet檢測
            detection = chardet.detect(raw_data)
            
            # 檢查BOM（字節(jié)順序標(biāo)記）
            bom_encoding = self._check_bom(raw_data)
            if bom_encoding:
                return bom_encoding, True
            
            if detection['confidence'] > 0.7:
                return detection['encoding'], False
            
            # 嘗試常見編碼
            for encoding in self.common_encodings:
                try:
                    raw_data.decode(encoding)
                    return encoding, False
                except UnicodeDecodeError:
                    continue
            
            return 'utf-8', False  # 默認回退
    
    def _check_bom(self, data):
        """
        檢查BOM標(biāo)記
        """
        bom_signatures = {
            b'\xff\xfe': 'utf-16-le',
            b'\xfe\xff': 'utf-16-be',
            b'\xff\xfe\x00\x00': 'utf-32-le',
            b'\x00\x00\xfe\xff': 'utf-32-be',
            b'\xef\xbb\xbf': 'utf-8-sig'
        }
        
        for signature, encoding in bom_signatures.items():
            if data.startswith(signature):
                return encoding
        
        return None
    
    def open_with_detected_encoding(self, file_path):
        """
        使用檢測到的編碼打開文件
        """
        encoding, has_bom = self.detect_encoding(file_path)
        print(f"檢測到編碼: {encoding} (BOM: {has_bom})")
        
        # 以二進制打開，然后動態(tài)包裝
        binary_file = open(file_path, 'rb')
        
        # 跳過BOM（如果存在）
        if has_bom:
            bom_size = len(self._get_bom_bytes(encoding))
            binary_file.seek(bom_size)
        
        # 創(chuàng)建TextIOWrapper
        text_file = io.TextIOWrapper(
            binary_file,
            encoding=encoding,
            errors='replace'  # 替換無法解碼的字符
        )
        
        return text_file
    
    def _get_bom_bytes(self, encoding):
        """
        獲取編碼對應(yīng)的BOM字節(jié)
        """
        bom_map = {
            'utf-8-sig': b'\xef\xbb\xbf',
            'utf-16-le': b'\xff\xfe',
            'utf-16-be': b'\xfe\xff',
            'utf-32-le': b'\xff\xfe\x00\x00',
            'utf-32-be': b'\x00\x00\xfe\xff'
        }
        return bom_map.get(encoding, b'')
 
# 使用示例
def demo_dynamic_encoding():
    """動態(tài)編碼演示"""
    adapter = DynamicEncodingAdapter()
    
    # 創(chuàng)建不同編碼的測試文件
    test_files = [
        ('utf-8_file.txt', 'UTF-8內(nèi)容', 'utf-8'),
        ('gbk_file.txt', 'GBK中文內(nèi)容', 'gbk'),
    ]
    
    for filename, content, encoding in test_files:
        with open(filename, 'w', encoding=encoding) as f:
            f.write(content)
    
    # 動態(tài)檢測和打開
    for filename, expected_content, expected_encoding in test_files:
        print(f"\n處理文件: {filename}")
        
        try:
            with adapter.open_with_detected_encoding(filename) as f:
                detected_content = f.read()
                print(f"預(yù)期: {expected_content}")
                print(f"讀取: {detected_content}")
                print(f"匹配: {detected_content == expected_content}")
        except Exception as e:
            print(f"錯誤: {e}")
        
        # 清理
        import os
        os.remove(filename)
 
demo_dynamic_encoding()

class RealtimeTranscoder:
    """
    實時編碼轉(zhuǎn)換器
    """
    
    def __init__(self, source_encoding='auto', target_encoding='utf-8'):
        self.source_encoding = source_encoding
        self.target_encoding = target_encoding
        self.detector = DynamicEncodingAdapter()
    
    def transcode_file(self, source_path, target_path):
        """
        轉(zhuǎn)換文件編碼
        """
        # 確定源編碼
        if self.source_encoding == 'auto':
            detected_encoding, has_bom = self.detector.detect_encoding(source_path)
            source_encoding = detected_encoding
        else:
            source_encoding = self.source_encoding
        
        print(f"轉(zhuǎn)換: {source_encoding} -> {self.target_encoding}")
        
        # 使用二進制模式打開兩個文件
        with open(source_path, 'rb') as src_binary, \
             open(target_path, 'wb') as tgt_binary:
            
            # 為源文件創(chuàng)建文本包裝器
            src_text = io.TextIOWrapper(
                src_binary,
                encoding=source_encoding,
                errors='replace'
            )
            
            # 為目標(biāo)文件創(chuàng)建文本包裝器
            tgt_text = io.TextIOWrapper(
                tgt_binary,
                encoding=self.target_encoding,
                errors='replace',
                write_through=True  # 立即寫入底層緩沖
            )
            
            # 逐塊轉(zhuǎn)換
            buffer_size = 4096
            while True:
                chunk = src_text.read(buffer_size)
                if not chunk:
                    break
                tgt_text.write(chunk)
            
            # 確保所有數(shù)據(jù)寫入
            tgt_text.flush()
            
            # 分離包裝器，避免關(guān)閉底層文件
            src_text.detach()
            tgt_text.detach()
        
        print(f"轉(zhuǎn)換完成: {target_path}")
    
    def transcode_stream(self, input_stream, output_stream):
        """
        轉(zhuǎn)換流編碼
        """
        # 創(chuàng)建臨時包裝器
        input_wrapper = io.TextIOWrapper(
            input_stream,
            encoding=self.source_encoding,
            errors='replace'
        )
        
        output_wrapper = io.TextIOWrapper(
            output_stream,
            encoding=self.target_encoding,
            errors='replace',
            write_through=True
        )
        
        try:
            # 傳輸數(shù)據(jù)
            while True:
                chunk = input_wrapper.read(1024)
                if not chunk:
                    break
                output_wrapper.write(chunk)
            
            output_wrapper.flush()
            
        finally:
            # 分離包裝器但不關(guān)閉底層流
            input_wrapper.detach()
            output_wrapper.detach()
 
# 使用示例
def demo_transcoding():
    """編碼轉(zhuǎn)換演示"""
    transcoder = RealtimeTranscoder('auto', 'utf-8')
    
    # 創(chuàng)建測試文件
    with open('source_gbk.txt', 'w', encoding='gbk') as f:
        f.write('這是GBK編碼的中文內(nèi)容')
    
    # 執(zhí)行轉(zhuǎn)換
    transcoder.transcode_file('source_gbk.txt', 'target_utf8.txt')
    
    # 驗證結(jié)果
    with open('target_utf8.txt', 'r', encoding='utf-8') as f:
        content = f.read()
        print(f"轉(zhuǎn)換結(jié)果: {content}")
    
    # 清理
    import os
    os.remove('source_gbk.txt')
    os.remove('target_utf8.txt')
 
demo_transcoding()

class MultiEncodingFileProcessor:
    """
    處理可能包含多種編碼的文件
    """
    
    def __init__(self):
        self.detector = DynamicEncodingAdapter()
    
    def process_mixed_encoding_file(self, file_path):
        """
        處理可能包含多種編碼的文件
        """
        results = {
            'sections': [],
            'encodings_found': set(),
            'errors': []
        }
        
        with open(file_path, 'rb') as binary_file:
            position = 0
            current_encoding = None
            current_buffer = bytearray()
            
            # 逐塊分析文件
            while True:
                chunk = binary_file.read(1024)
                if not chunk:
                    break
                
                current_buffer.extend(chunk)
                
                # 嘗試檢測當(dāng)前塊的編碼
                try:
                    detected_encoding, _ = self.detector.detect_encoding_from_bytes(
                        bytes(current_buffer)
                    )
                    
                    if current_encoding != detected_encoding:
                        # 編碼變化，處理當(dāng)前緩沖區(qū)
                        if current_encoding and current_buffer:
                            self._process_section(
                                bytes(current_buffer),
                                current_encoding,
                                position,
                                results
                            )
                            position += len(current_buffer)
                            current_buffer = bytearray()
                        
                        current_encoding = detected_encoding
                
                except Exception as e:
                    results['errors'].append(f"位置 {position}: {e}")
                    current_buffer = bytearray()
                    continue
            
            # 處理最后的部分
            if current_buffer and current_encoding:
                self._process_section(
                    bytes(current_buffer),
                    current_encoding,
                    position,
                    results
                )
        
        return results
    
    def _process_section(self, data, encoding, position, results):
        """
        處理文件的一個編碼段落
        """
        try:
            decoded = data.decode(encoding, errors='replace')
            results['sections'].append({
                'position': position,
                'length': len(data),
                'encoding': encoding,
                'content': decoded,
                'success': True
            })
            results['encodings_found'].add(encoding)
        except Exception as e:
            results['sections'].append({
                'position': position,
                'length': len(data),
                'encoding': encoding,
                'error': str(e),
                'success': False
            })
            results['errors'].append(f"解碼失敗 {position}: {e}")
 
    def detect_encoding_from_bytes(self, data):
        """
        從字節(jié)數(shù)據(jù)檢測編碼
        """
        try:
            detection = chardet.detect(data)
            if detection['confidence'] > 0.5:
                return detection['encoding'], False
            
            # 嘗試常見編碼
            for encoding in self.common_encodings:
                try:
                    data.decode(encoding)
                    return encoding, False
                except UnicodeDecodeError:
                    continue
            
            return 'utf-8', False
        except:
            return 'utf-8', False
 
# 使用示例
def demo_mixed_processing():
    """混合編碼處理演示"""
    processor = MultiEncodingFileProcessor()
    
    # 創(chuàng)建混合編碼測試文件
    with open('mixed_encoding.txt', 'wb') as f:
        # UTF-8部分
        f.write('UTF-8部分: Hello, 世界!\n'.encode('utf-8'))
        # GBK部分
        f.write('GBK部分: 中文內(nèi)容\n'.encode('gbk'))
        # 再回到UTF-8
        f.write('返回UTF-8: 繼續(xù)內(nèi)容\n'.encode('utf-8'))
    
    # 處理文件
    results = processor.process_mixed_encoding_file('mixed_encoding.txt')
    
    print("=== 混合編碼處理結(jié)果 ===")
    print(f"找到編碼: {results['encodings_found']}")
    print(f"段落數(shù): {len(results['sections'])}")
    print(f"錯誤數(shù): {len(results['errors'])}")
    
    for i, section in enumerate(results['sections']):
        print(f"\n段落 {i+1}:")
        print(f"  編碼: {section['encoding']}")
        print(f"  位置: {section['position']}")
        print(f"  長度: {section['length']}")
        if section['success']:
            print(f"  內(nèi)容: {section['content'][:50]}...")
        else:
            print(f"  錯誤: {section['error']}")
    
    # 清理
    import os
    os.remove('mixed_encoding.txt')
 
demo_mixed_processing()

import mmap
import io
 
class MappedFileEncoder:
    """
    使用內(nèi)存映射高效處理大文件編碼
    """
    
    def __init__(self):
        self.detector = DynamicEncodingAdapter()
    
    def process_large_file(self, file_path, target_encoding='utf-8'):
        """
        處理大文件的編碼轉(zhuǎn)換
        """
        results = {
            'processed_bytes': 0,
            'converted_chunks': 0,
            'errors': []
        }
        
        with open(file_path, 'r+b') as f:
            # 創(chuàng)建內(nèi)存映射
            with mmap.mmap(f.fileno(), 0, access=mmap.ACCESS_READ) as mm:
                # 檢測整體編碼
                overall_encoding, _ = self.detector.detect_encoding_from_bytes(
                    mm[:min(len(mm), 4096)]
                )
                
                print(f"檢測到整體編碼: {overall_encoding}")
                
                # 分塊處理
                chunk_size = 64 * 1024  # 64KB塊
                position = 0
                
                while position < len(mm):
                    # 處理當(dāng)前塊
                    chunk_end = min(position + chunk_size, len(mm))
                    chunk = mm[position:chunk_end]
                    
                    try:
                        # 解碼當(dāng)前塊
                        decoded = chunk.decode(overall_encoding, errors='replace')
                        
                        # 轉(zhuǎn)換為目標(biāo)編碼
                        encoded = decoded.encode(target_encoding, errors='replace')
                        
                        results['processed_bytes'] += len(chunk)
                        results['converted_chunks'] += 1
                        
                        # 這里可以處理編碼后的數(shù)據(jù)
                        # 例如寫入新文件或進行其他處理
                        
                    except Exception as e:
                        results['errors'].append(f"位置 {position}: {e}")
                    
                    position = chunk_end
        
        return results
    
    def create_mapped_text_wrapper(self, file_path, encoding='utf-8'):
        """
        創(chuàng)建基于內(nèi)存映射的文本包裝器
        """
        # 打開文件并創(chuàng)建內(nèi)存映射
        file_obj = open(file_path, 'r+b')
        mmapped = mmap.mmap(file_obj.fileno(), 0, access=mmap.ACCESS_READ)
        
        # 創(chuàng)建字節(jié)IO包裝內(nèi)存映射
        buffer = io.BytesIO(mmapped)
        
        # 創(chuàng)建文本包裝器
        text_wrapper = io.TextIOWrapper(
            buffer,
            encoding=encoding,
            errors='replace'
        )
        
        return {
            'file_obj': file_obj,
            'mmapped': mmapped,
            'buffer': buffer,
            'text_wrapper': text_wrapper
        }
 
# 使用示例
def demo_mapped_processing():
    """內(nèi)存映射處理演示"""
    encoder = MappedFileEncoder()
    
    # 創(chuàng)建測試大文件
    large_content = "測試內(nèi)容\n" * 10000
    with open('large_file.txt', 'w', encoding='gbk') as f:
        f.write(large_content)
    
    # 處理文件
    results = encoder.process_large_file('large_file.txt', 'utf-8')
    
    print("=== 內(nèi)存映射處理結(jié)果 ===")
    print(f"處理字節(jié): {results['processed_bytes']}")
    print(f"處理塊數(shù): {results['converted_chunks']}")
    print(f"錯誤數(shù): {len(results['errors'])}")
    
    # 清理
    import os
    os.remove('large_file.txt')
 
demo_mapped_processing()

class OptimizedEncodingProcessor:
    """
    優(yōu)化的編碼處理器
    """
    
    def __init__(self, buffer_size=8192, encoding_cache_size=1000):
        self.buffer_size = buffer_size
        self.encoding_cache = {}
        self.cache_size = encoding_cache_size
        self.detector = DynamicEncodingAdapter()
    
    def optimized_transcode(self, source_path, target_path, 
                          source_encoding=None, target_encoding='utf-8'):
        """
        優(yōu)化的編碼轉(zhuǎn)換
        """
        # 檢測源編碼（如果未指定）
        if source_encoding is None:
            source_encoding, _ = self.detector.detect_encoding(source_path)
        
        # 使用緩沖策略
        with open(source_path, 'rb', buffering=self.buffer_size) as src, \
             open(target_path, 'wb', buffering=self.buffer_size) as tgt:
            
            # 創(chuàng)建緩沖的文本包裝器
            src_text = io.TextIOWrapper(
                src,
                encoding=source_encoding,
                errors='replace',
                line_buffering=False
            )
            
            tgt_text = io.TextIOWrapper(
                tgt,
                encoding=target_encoding,
                errors='replace',
                write_through=True,
                line_buffering=False
            )
            
            # 使用大塊傳輸
            while True:
                chunk = src_text.read(self.buffer_size)
                if not chunk:
                    break
                tgt_text.write(chunk)
            
            # 確保所有數(shù)據(jù)寫入
            tgt_text.flush()
            
            # 分離包裝器
            src_text.detach()
            tgt_text.detach()
    
    def batch_process_files(self, file_list, target_encoding='utf-8'):
        """
        批量處理文件
        """
        results = []
        
        for file_path in file_list:
            try:
                # 檢查編碼緩存
                if file_path in self.encoding_cache:
                    source_encoding = self.encoding_cache[file_path]
                else:
                    source_encoding, _ = self.detector.detect_encoding(file_path)
                    # 更新緩存
                    if len(self.encoding_cache) >= self.cache_size:
                        self.encoding_cache.clear()
                    self.encoding_cache[file_path] = source_encoding
                
                # 處理文件
                temp_path = f"{file_path}.converted"
                self.optimized_transcode(
                    file_path, temp_path, source_encoding, target_encoding
                )
                
                results.append({
                    'file': file_path,
                    'success': True,
                    'source_encoding': source_encoding,
                    'target_encoding': target_encoding
                })
                
                # 這里可以替換原文件或進行其他操作
                
            except Exception as e:
                results.append({
                    'file': file_path,
                    'success': False,
                    'error': str(e)
                })
        
        return results
 
# 使用示例
def demo_optimized_processing():
    """優(yōu)化處理演示"""
    processor = OptimizedEncodingProcessor()
    
    # 創(chuàng)建測試文件
    test_files = []
    for i in range(3):
        filename = f'test_file_{i}.txt'
        encoding = 'gbk' if i % 2 == 0 else 'utf-8'
        with open(filename, 'w', encoding=encoding) as f:
            f.write(f'測試文件 {i} - 編碼: {encoding}')
        test_files.append(filename)
    
    # 批量處理
    results = processor.batch_process_files(test_files)
    
    print("=== 批量處理結(jié)果 ===")
    for result in results:
        if result['success']:
            print(f"成功: {result['file']} "
                  f"({result['source_encoding']} -> {result['target_encoding']})")
        else:
            print(f"失敗: {result['file']} - {result['error']}")
    
    # 清理
    import os
    for file in test_files:
        if os.path.exists(file):
            os.remove(file)
        temp_file = f"{file}.converted"
        if os.path.exists(temp_file):
            os.remove(temp_file)
 
demo_optimized_processing()

class RobustEncodingProcessor:
    """
    健壯的編碼處理框架
    """
    
    def __init__(self):
        self.detector = DynamicEncodingAdapter()
        self.retry_strategies = [
            self._retry_with_different_encoding,
            self._retry_with_error_replacement,
            self._retry_with_byte_preservation
        ]
    
    def safe_read_file(self, file_path, preferred_encoding=None):
        """
        安全讀取文件，使用多種恢復(fù)策略
        """
        attempts = []
        
        # 嘗試1: 首選編碼或自動檢測
        try:
            if preferred_encoding:
                encoding = preferred_encoding
            else:
                encoding, _ = self.detector.detect_encoding(file_path)
            
            content = self._read_with_encoding(file_path, encoding)
            return {
                'success': True,
                'content': content,
                'encoding': encoding,
                'attempts': attempts
            }
            
        except Exception as first_error:
            attempts.append({
                'strategy': 'primary',
                'encoding': preferred_encoding,
                'error': str(first_error)
            })
        
        # 嘗試恢復(fù)策略
        for strategy in self.retry_strategies:
            try:
                content, encoding = strategy(file_path)
                attempts.append({
                    'strategy': strategy.__name__,
                    'encoding': encoding,
                    'success': True
                })
                return {
                    'success': True,
                    'content': content,
                    'encoding': encoding,
                    'attempts': attempts
                }
            except Exception as e:
                attempts.append({
                    'strategy': strategy.__name__,
                    'error': str(e)
                })
        
        return {
            'success': False,
            'attempts': attempts,
            'error': '所有恢復(fù)策略都失敗'
        }
    
    def _read_with_encoding(self, file_path, encoding):
        """使用指定編碼讀取文件"""
        with open(file_path, 'r', encoding=encoding, errors='strict') as f:
            return f.read()
    
    def _retry_with_different_encoding(self, file_path):
        """嘗試不同編碼"""
        for encoding in ['utf-8', 'gbk', 'iso-8859-1']:
            try:
                content = self._read_with_encoding(file_path, encoding)
                return content, encoding
            except:
                continue
        raise ValueError("所有備選編碼都失敗")
    
    def _retry_with_error_replacement(self, file_path):
        """使用錯誤替換策略"""
        with open(file_path, 'r', encoding='utf-8', errors='replace') as f:
            content = f.read()
        return content, 'utf-8-with-replace'
    
    def _retry_with_byte_preservation(self, file_path):
        """保留原始字節(jié)"""
        with open(file_path, 'rb') as f:
            content = f.read()
        return content.hex(), 'hex-encoded'
 
# 使用示例
def demo_robust_processing():
    """健壯處理演示"""
    processor = RobustEncodingProcessor()
    
    # 創(chuàng)建有問題的測試文件
    problematic_content = '正常內(nèi)容'.encode('utf-8') + b'\xff\xfe' + '后續(xù)內(nèi)容'.encode('utf-8')
    with open('problematic.txt', 'wb') as f:
        f.write(problematic_content)
    
    # 嘗試安全讀取
    result = processor.safe_read_file('problematic.txt')
    
    print("=== 健壯處理結(jié)果 ===")
    print(f"成功: {result['success']}")
    if result['success']:
        print(f"編碼: {result['encoding']}")
        print(f"內(nèi)容預(yù)覽: {result['content'][:100]}...")
    else:
        print(f"錯誤: {result['error']}")
    
    print("\n嘗試記錄:")
    for attempt in result['attempts']:
        if 'success' in attempt:
            print(f"  ? {attempt['strategy']} ({attempt['encoding']})")
        else:
            print(f"  ? {attempt['strategy']}: {attempt['error']}")
    
    # 清理
    import os
    os.remove('problematic.txt')
 
demo_robust_processing()