from pathlib import Path

# 創(chuàng)建Path對象的幾種方式
current_path = Path()  # 當(dāng)前目錄
relative_path = Path('folder/subfolder')  # 相對路徑
absolute_path = Path('/home/user/documents')  # 絕對路徑（Linux/Mac）
windows_path = Path('C:/Users/Name/Documents')  # 絕對路徑（Windows）

# 使用類方法
current_dir = Path.cwd()  # 當(dāng)前工作目錄
home_dir = Path.home()  # 用戶主目錄

# 路徑拼接
base_dir = Path('/base/demo')
sub_path = base_dir / 'subfolder' / 'file.txt'
print(sub_path)  # 輸出: /base/demo/subfolder/file.txt

# 解析路徑組成部分
path = Path('D:/Users/base_demo/demo.py')
print(path.name)      # 文件名（含后綴）: demo.py
print(path.stem)      # 文件名（不含后綴）: demo
print(path.suffix)    # 文件后綴: .py
print(path.parent)    # 父目錄: D:/Users/base_demo
print(path.anchor)    # 錨點(diǎn)（驅(qū)動器）: D:

path = Path('/path/to/file.txt')

# 路徑判斷
print(path.exists())     # 路徑是否存在
print(path.is_file())    # 是否是文件
print(path.is_dir())     # 是否是目錄
print(path.is_absolute()) # 是否是絕對路徑

# 路徑解析
print(path.resolve())    # 獲取絕對路徑，解析任何符號鏈接
print(path.as_uri())     # 將路徑表示為file URL

# 創(chuàng)建目錄
new_dir = Path('new_directory')
new_dir.mkdir(exist_ok=True)  # exist_ok=True表示目錄已存在時不報錯

# 創(chuàng)建多級目錄
deep_dir = Path('path/to/deep/directory')
deep_dir.mkdir(parents=True, exist_ok=True)  # parents=True創(chuàng)建所有必要的父目錄

# 刪除目錄（目錄必須為空）
empty_dir = Path('empty_directory')
empty_dir.rmdir()

path = Path('.')

# 遍歷直接子項(xiàng)
for item in path.iterdir():
    if item.is_file():
        print(f"文件: {item.name}")
    elif item.is_dir():
        print(f"目錄: {item.name}")

# 使用glob模式匹配
for py_file in path.glob('*.py'):
    print(f"Python文件: {py_file}")

# 遞歸匹配（搜索子目錄）
for py_file in path.rglob('*.py'):
    print(f"Python文件: {py_file}")

file_path = Path('example.txt')

# 寫入文件
file_path.write_text('Hello, World!')  # 寫入文本

# 讀取文件
content = file_path.read_text()
print(content)

# 二進(jìn)制讀寫
data = b'Binary data'
file_path.write_bytes(data)  # 寫入二進(jìn)制數(shù)據(jù)
binary_content = file_path.read_bytes()  # 讀取二進(jìn)制數(shù)據(jù)

# 使用open方法（更細(xì)粒度的控制）
with file_path.open('a') as f:  # 追加模式
    f.write('\nAppended text')

file_path = Path('example.txt')

# 獲取文件屬性
stat_info = file_path.stat()
print(f"文件大小: {stat_info.st_size} 字節(jié)")
print(f"創(chuàng)建時間: {stat_info.st_ctime}")
print(f"修改時間: {stat_info.st_mtime}")

# 文件操作
new_path = file_path.rename('new_name.txt')  # 重命名
copied_path = new_path.replace('backup.txt')  # 移動/復(fù)制（會覆蓋已存在文件）

# 刪除文件
file_path.unlink(missing_ok=True)  # missing_ok=True表示文件不存在時不報錯

from pathlib import Path
import shutil
import time

class FileIO:
    """
    使用 pathlib 封裝常見文件路徑操作的實(shí)用類

    該類提供了一系列用于文件和目錄操作的方法，包括遍歷、篩選、清空文件夾等功能。
    所有路徑操作均基于 pathlib 庫，確?？缙脚_兼容性。
    """

    def __init__(self, source_folder: None |str | Path, target_folder:None |str | Path) -> None:
        """
        初始化 FileIO 實(shí)例

        Args:
            source_folder: 源目錄路徑，可以是字符串或 Path 對象
        """
        self.source_folder = Path(source_folder)  # 保證路徑是 Path 格式
        self.target_folder = Path(target_folder) #目標(biāo)文件
        if not self.target_folder.exists(): #目標(biāo)文件夾不存在時，新建
            self.target_folder.mkdir(parents=True, exist_ok=True)

    def list_folder_names(self, recursive: bool = True) -> list[str]:
        """
        獲取文件夾名稱列表

        Args:
            recursive: 是否遞歸獲取所有子文件夾，默認(rèn)為 True
                      True - 遞歸獲取所有子文件夾
                      False - 只獲取直接子文件夾

        Returns:
            文件夾名稱列表
        """
        folder_path = self.source_folder
        folder_names = [item.name
                        for item in (folder_path.rglob('*') if recursive else folder_path.iterdir()) #iterdir()比glob('*')更高效，
                        if item.is_dir()]
        return folder_names

    def list_folder_paths(self, recursive: bool = True) -> list[Path]:
        """
        獲取文件夾路徑列表

        Args:
            recursive: 是否遞歸獲取所有子文件夾路徑

        Returns:
            Path 對象列表，包含所有匹配的文件夾路徑
        """
        folder_path = self.source_folder
        folder_paths = [item
                        for item in (folder_path.rglob('*') if recursive else folder_path.iterdir())
                        if item.is_dir()]
        return folder_paths

    def list_file_names(self, recursive: bool = True, include_extension: bool = True) -> list[str]:
        """
        獲取文件名列表

        Args:
            recursive: 是否遞歸獲取所有子文件
            include_extension: 是否包含文件擴(kuò)展名
                             True - 包含擴(kuò)展名 (e.g., "document.txt")
                             False - 不包含擴(kuò)展名 (e.g., "document")

        Returns:
            文件名列表
        """
        folder_path = self.source_folder
        file_names = [
            item.name if include_extension else item.stem
            for item in (folder_path.rglob('*') if recursive else folder_path.iterdir())
            if item.is_file()
        ]
        return file_names

    def list_file_paths(self, recursive: bool = True) -> list[Path]:
        """
        獲取文件路徑列表

        Args:
            recursive: 是否遞歸獲取所有子文件路徑

        Returns:
            Path 對象列表，包含所有匹配的文件路徑
        """
        folder_path = self.source_folder
        file_paths = [item
                      for item in (folder_path.rglob('*') if recursive else folder_path.iterdir())
                      if item.is_file()]

        return file_paths

    @staticmethod
    def filter_by_strings(items: list[str] | list[Path], target_strings: list[str], logical_or: bool = True) -> list[str]:
        """
        根據(jù)字符串列表篩選項(xiàng)目

        Args:
            items: 要篩選的項(xiàng)目列表
            target_strings: 目標(biāo)字符串列表，用于篩選條件
            logical_or: 邏輯操作類型
                       True - 邏輯或（包含任意一個目標(biāo)字符串即匹配）
                       False - 邏輯與（包含所有目標(biāo)字符串才匹配）

        Returns:
            篩選后的項(xiàng)目列表
        """
        if logical_or:  # 邏輯OR：包含任意一個字符串即可
            filtered_items = [item
                              for item in items
                              if any(target_str in str(item) for target_str in target_strings)
            ]
        else:  # 邏輯AND：包含所有字符串
            filtered_items = [item
                              for item in items
                              if all(target_str in str(item) for target_str in target_strings)
            ]
        return filtered_items

    @staticmethod
    def clear_folder(target_dir: str|Path, max_attempts: int = 3, delay_seconds: float = 3) -> bool|None:
        """
        通過刪除并重建文件夾的方式來清空目標(biāo)文件夾，支持重試機(jī)制

        Args:
            max_attempts: 最大嘗試次數(shù)，默認(rèn)為3次
            delay_seconds: 每次重試前的等待時間（秒），默認(rèn)為3秒

        Returns:
            bool: 成功清空返回 True，失敗返回 False

        Raises:
            PermissionError: 當(dāng)文件被占用且無法刪除時
            OSError: 當(dāng)發(fā)生其他操作系統(tǒng)錯誤時
        """
        attempts = 0
        while attempts < max_attempts:
            try:
                # 嘗試清空文件夾的核心邏輯
                source_folder = Path(target_dir)
                if source_folder.exists():
                    shutil.rmtree(source_folder)  # 遞歸刪除整個文件夾
                    # 短暫延遲確保刪除完全生效
                    time.sleep(0.05)

                source_folder.mkdir(exist_ok=True)  # 重新創(chuàng)建空文件夾
                print(f"成功清空文件夾: {source_folder}")
                return True

            except PermissionError as error:
                # 捕獲權(quán)限錯誤（通常是因?yàn)槲募徽加茫?
                attempts += 1
                print(f"嘗試 {attempts}/{max_attempts} 失敗: 文件可能正被其他程序占用。錯誤信息: {error}")

                if attempts < max_attempts:
                    print(f"等待 {delay_seconds} 秒后重試...")
                    time.sleep(delay_seconds)
                else:
                    print(f"已達(dá)到最大重試次數(shù) {max_attempts}，無法清空文件夾。")
                    return False

            except OSError as error:
                # 捕獲其他操作系統(tǒng)錯誤，例如路徑無效等
                print(f"發(fā)生操作系統(tǒng)錯誤: {error}")
                return False

    def copy_directory_structure(self, recursive: bool = True) -> None:
        """
        復(fù)制源目錄結(jié)構(gòu)到目標(biāo)位置（不復(fù)制文件內(nèi)容）

        遞歸復(fù)制源目錄下的所有子目錄結(jié)構(gòu)到目標(biāo)位置，但不會復(fù)制任何文件內(nèi)容，
        只創(chuàng)建空的目錄結(jié)構(gòu)。

        Args:
            target_dir: 目標(biāo)目錄路徑，可以是字符串或 Path 對象
        """
        source_path = self.source_folder
        target_path = self.target_folder

        # 確保目標(biāo)根目錄存在
        target_path.mkdir(parents=True, exist_ok=True)

        # 使用 rglob 遞歸遍歷源目錄下的所有子目錄
        for dir_path in (source_path.rglob('*') if recursive else source_path.glob('*')):
            if dir_path.is_dir():
                # 計(jì)算當(dāng)前目錄相對于源目錄的相對路徑
                try:
                    relative_path = dir_path.relative_to(source_path)
                except ValueError:
                    # 如果 dir_path 不是 source_path 的子路徑，跳過
                    continue

                # 構(gòu)建目標(biāo)目錄路徑并創(chuàng)建
                target_subdir = target_path / relative_path
                target_subdir.mkdir(parents=True, exist_ok=True)
                print(f"創(chuàng)建目錄: {target_subdir}")


    def find_leaf_directories(self) -> list[Path]:
        """
        查找并返回所有葉子目錄（不包含子目錄的目錄）

        Returns:
            葉子目錄的 Path 對象列表
        """
        source_path = self.source_folder
        leaf_directories = []

        # 識別葉子目錄：沒有子目錄的目錄就是葉子目錄
        for dir_path in source_path.rglob('*'):
            if dir_path.is_dir():
                # 檢查當(dāng)前目錄是否包含子目錄
                has_subdirectories = any(item.is_dir() for item in dir_path.iterdir())

                if not has_subdirectories:
                    leaf_directories.append(dir_path)

        # 輸出所有葉子目錄信息
        result_paths = []
        print("\n所有葉子目錄（最深層次的子目錄）:")
        for leaf_path in leaf_directories:
            # 計(jì)算相對于源目錄的路徑用于顯示
            try:
                relative_leaf_path = leaf_path.relative_to(source_path)
                result_paths.append(source_path / relative_leaf_path)

                # 計(jì)算目錄深度
                depth = len(relative_leaf_path.parts)
                print(f"- {relative_leaf_path} (深度: {depth})")
            except ValueError:
                # 如果路徑計(jì)算出錯，跳過
                continue

        return result_paths

    #將一個文件夾里的所有指定格式文件復(fù)制到另一個目標(biāo)文件夾
    def copy_files(self,  file_extension='.tif') -> None:
        source_files = self.list_file_paths(True) #獲取原始文件夾里所有的文件路徑
        for source_file in source_files:
            if file_extension in str(source_file):
                shutil.copy2(source_file, self.target_folder)#將原始文件夾里所有的文件復(fù)制到對應(yīng)文件夾
                print(f"已復(fù)制: {source_file} -> {target_folder}")
    #將一個文件夾里的所有目錄和指定格式文件復(fù)制到另一個文件夾
    def copy_folders_and_files(self, file_extension='.tif') -> None:
        self.copy_directory_structure(True)
        source_files = self.list_file_paths(True)  # 獲取原始文件夾里所有的文件路徑
        for source_file in source_files:
            if file_extension in str(source_file):
                # 計(jì)算 source_file 相對于 self.source_folder 的相對路徑
                relative_path = source_file.relative_to(self.source_folder)
                # 將相對路徑拼接到目標(biāo)文件夾下
                target_file = self.target_folder / relative_path
                shutil.copy2(source_file, target_file)  # 將原始文件夾里所有的文件復(fù)制到對應(yīng)文件夾
                print(f"已復(fù)制: {source_file} -> {target_file}")
    #將一個文件復(fù)制到目標(biāo)文件夾里，并重命名
    @staticmethod
    def copy_rename_file(source_file_path:str|Path, target_folder:str|Path,new_filename:str) -> None:
        extension_name = Path(source_file_path).suffix
        target_file_path = Path(target_folder) / Path(new_filename +extension_name)
        shutil.copy2(source_file_path, target_file_path)
        print(f"已復(fù)制: {source_file_path} -> {target_file_path}")
if __name__ == '__main__':
    # # 測試路徑，請?zhí)鎿Q為實(shí)際路徑
    source_folder = Path(r"F:\source")
    target_folder = Path(r"F:\target")
    file_io = FileIO(source_folder, target_folder)  # 實(shí)例化類

    target_strings = [".tif", ".docx"]
    #
    # 測試直接子文件夾相關(guān)方法
    print("=== 直接子文件夾 ===")
    current_folder_names = file_io.list_folder_names(False) #獲取直接文件夾名
    current_folder_paths = file_io.list_folder_paths(False) #獲取直接文件夾路徑
    filtered_current_folder_paths_and = file_io.filter_by_strings(current_folder_paths, target_strings, False) #按照邏輯與篩選含所有關(guān)鍵字的直接子文件夾路徑
    filtered_current_folder_paths_or = file_io.filter_by_strings(current_folder_paths, target_strings, True) #按照邏輯或篩選含任一關(guān)鍵字的直接子文件夾路徑

    print("直接子文件夾名稱列表:", current_folder_names)
    print("直接子文件夾路徑列表:", current_folder_paths)
    print("AND條件過濾的文件夾:",  filtered_current_folder_paths_and)
    print("OR條件過濾的文件夾:", filtered_current_folder_paths_or)

    # 測試所有子文件夾相關(guān)方法
    print("\n=== 所有子文件夾 ===")
    all_folder_names = file_io.list_folder_names(True) #獲取所有子文件夾名
    all_folder_paths = file_io.list_folder_paths(True) #獲取所有子文件夾路徑
    filtered_all_folder_paths_and = file_io.filter_by_strings(all_folder_paths, target_strings, False) #按照邏輯與篩選含所有關(guān)鍵字的子文件夾路徑
    filtered_all_folder_paths_or =  file_io.filter_by_strings(all_folder_paths, target_strings, True) #按照邏輯或篩選含任一關(guān)鍵字的子文件夾路徑

    print("所有子文件夾名稱:", all_folder_names)
    print("所有子文件夾路徑:", all_folder_paths)
    print("AND條件過濾的所有子文件夾:", filtered_all_folder_paths_and)
    print("OR條件過濾的所有子文件夾:", filtered_all_folder_paths_or )

    # 測試直接子文件相關(guān)方法
    print("\n=== 直接子文件 ===")
    current_file_lists_with_extension = file_io.list_file_names(False,True) #獲取所有直接文件的名稱，有擴(kuò)展名
    current_file_lists_no_extension = file_io.list_file_names(False,False) #獲取所有直接文件的名稱，無擴(kuò)展名
    current_file_path_lists = file_io.list_file_paths(False) #獲取直接文件路徑
    filtered_file_path_lists_and = file_io.filter_by_strings(current_file_path_lists, target_strings, False) #按照邏輯與篩選含所有關(guān)鍵字的直接子文件路徑
    filtered_file_path_lists_or = file_io.filter_by_strings(current_file_path_lists, target_strings, True) #按照邏輯或篩選含任一關(guān)鍵字的直接子文件路徑

    print("帶擴(kuò)展名的文件:", current_file_lists_with_extension)
    print("不帶擴(kuò)展名的文件:", current_file_lists_no_extension)
    print("文件路徑列表:", current_file_path_lists )
    print("AND條件過濾的文件:", filtered_file_path_lists_and)
    print("OR條件過濾的文件:", filtered_file_path_lists_or)

    # 測試所有子文件相關(guān)方法
    print("\n=== 所有子文件 ===")
    all_file_lists_with_extension = file_io.list_file_names(True,True) #獲取所有文件的名稱，有擴(kuò)展名
    all_file_lists_no_extension = file_io.list_file_names(True,False) #獲取所有文件的名稱，無擴(kuò)展名
    all_file_path_lists = file_io.list_file_paths(True) #獲取所有文件路徑
    filtered_all_file_path_lists_and = file_io.filter_by_strings(all_file_path_lists, target_strings, False) #按照邏輯與篩選含所有關(guān)鍵字的所有文件路徑
    filtered_all_file_path_lists_or = file_io.filter_by_strings(all_file_path_lists, target_strings, True) #按照邏輯或篩選含任一關(guān)鍵字的所有文件路徑

    print("所有文件(帶擴(kuò)展名):", all_file_lists_with_extension)
    print("所有文件(不帶擴(kuò)展名):", all_file_lists_no_extension)
    print("所有文件路徑:", all_file_path_lists)
    print("AND條件過濾的所有文件:", filtered_all_file_path_lists_and)
    print("OR條件過濾的所有文件:", filtered_all_file_path_lists_or)

    #清空目標(biāo)文件夾里的所有內(nèi)容
    file_io.clear_folder(file_io.target_folder)
    #復(fù)制所有目錄
    file_io.copy_directory_structure(True) #True，復(fù)制所有目錄，F(xiàn)alse，復(fù)制當(dāng)前目錄
    #找到所有葉子目錄
    all_leaves = file_io.find_leaf_directories()
    print(all_leaves)
    # 清空目標(biāo)文件夾里的所有內(nèi)容
    file_io.clear_folder(file_io.target_folder)
    #復(fù)制特定格式的文件到指定目錄
    file_io.copy_files(".docx")
    # 清空目標(biāo)文件夾里的所有內(nèi)容
    file_io.clear_folder(file_io.target_folder)
    #復(fù)制并重命名
    i=0
    for filtered_all_file_path_lists_or  in filtered_all_file_path_lists_or:
        file_io.copy_rename_file(filtered_all_file_path_lists_or,file_io.target_folder,str(i))
        i = i + 1