from typing import List, Dict, Any
from .base import BaseMixin
from ..const import API_PATHS


class FileManagement(BaseMixin):
    async def name(self, file_id: int, file_name: str) -> Dict[str, Any]:
        """
        修改文件名
        
        修改指定文件的名称。
        
        Args:
            file_id: 文件ID
            file_name: 新的文件名
        
        Returns:
            Dict[str, Any]: API响应数据
            
        Returns Data Structure:
            {
                "code": 0,
                "message": "ok",
                "data": null
            }
        
        Example:
            >>> result = await file_management.name(12345, "新文件名.txt")
            >>> if result["code"] == 0:
            ...     print("重命名成功")
        """
        return await self._send_request(
            API_PATHS.rename_file,
            json={
                "fileId": file_id,
                "fileName": file_name
            }
        )

    async def rename_batch(self, rename_list: List[str]) -> Dict[str, Any]:
        """
        批量重命名
        
        批量重命名文件，最多支持同时30个文件重命名。
        
        Args:
            rename_list: 重命名列表，每个成员格式为"文件ID|新的文件名"
                        例如: ["12345|新文件名1.txt", "12346|新文件名2.txt"]
        
        Returns:
            Dict[str, Any]: API响应数据
            
        Returns Data Structure:
            {
                "code": 0,
                "message": "ok",
                "data": {
                    "successList": [
                        {
                            "fileID": 12345,
                            "updateAt": "2024-01-01 12:00:00"
                        }
                    ],
                    "failList": [
                        {
                            "fileID": 12346,
                            "message": "错误原因"
                        }
                    ]
                }
            }
        
        Example:
            >>> rename_list = ["12345|新文件名1.txt", "12346|新文件名2.txt"]
            >>> result = await file_management.rename_batch(rename_list)
            >>> success_count = len(result["data"]["successList"])
            >>> fail_count = len(result["data"]["failList"])
        """
        return await self._send_request(
            API_PATHS.batch_rename,
            json={
                "renameList": rename_list
            }
        )

    async def delete(self, file_ids: List[int]) -> Dict[str, Any]:
        """
        删除文件
        
        将文件删除到回收站。删除的文件会放入回收站中，
        可以通过recover接口恢复。
        
        注意：一次性最大不能超过100个文件。
        
        Args:
            file_ids: 文件ID数组，最多100个
        
        Returns:
            Dict[str, Any]: API响应数据
            
        Returns Data Structure:
            {
                "code": 0,
                "message": "ok",
                "data": null
            }
        
        Example:
            >>> result = await file_management.delete([12345, 12346])
            >>> if result["code"] == 0:
            ...     print("删除成功")
        """
        return await self._send_request(
            API_PATHS.trash,
            json={
                "fileIDs": file_ids
            }
        )

    async def copy(self, file_id: int, target_dir_id: int) -> Dict[str, Any]:
        """
        复制文件
        
        将文件复制到指定目录。此接口仅支持单个文件复制。
        
        Args:
            file_id: 要复制的文件ID
            target_dir_id: 目标目录ID
        
        Returns:
            Dict[str, Any]: API响应数据
            
        Returns Data Structure:
            {
                "code": 0,
                "message": "ok",
                "data": {
                    "sourceFileId": 12345,
                    "targetFileId": 67890
                }
            }
        
        Example:
            >>> result = await file_management.copy(12345, 67890)
            >>> if result["code"] == 0:
            ...     new_file_id = result["data"]["targetFileId"]
        """
        return await self._send_request(
            API_PATHS.copy,
            json={
                "fileId": file_id,
                "targetDirId": target_dir_id
            }
        )

    async def copy_async(self, file_ids: List[int], target_dir_id: int) -> Dict[str, Any]:
        """
        异步复制文件
        
        批量复制文件，单级最多支持3000个文件。
        复制过程是异步的，需要通过async_copy_process查询进度。
        
        Args:
            file_ids: 要复制的文件ID数组，最多3000个
            target_dir_id: 目标目录ID
        
        Returns:
            Dict[str, Any]: API响应数据
            
        Returns Data Structure:
            {
                "code": 0,
                "message": "ok",
                "data": {
                    "taskId": 12345
                }
            }
        
        Example:
            >>> result = await file_management.copy_async([12345, 12346], 67890)
            >>> task_id = result["data"]["taskId"]
            >>> # 使用task_id查询复制进度
        """
        return await self._send_request(
            API_PATHS.async_copy,
            json={
                "fileIds": file_ids,
                "targetDirID": target_dir_id
            }
        )

    async def copy_progress(self, task_id: int) -> Dict[str, Any]:
        """
        查询异步复制进度
        
        查询异步复制任务的执行进度和状态。
        
        Args:
            task_id: 任务ID，从async_copy接口获取
        
        Returns:
            Dict[str, Any]: API响应数据
            
        Returns Data Structure:
            {
                "code": 0,
                "message": "ok",
                "data": {
                    "taskId": 12345,
                    "status": 2
                }
            }
        
        任务状态说明:
            0: 待处理
            1: 进行中
            2: 已完成
            3: 失败
        
        Example:
            >>> result = await file_management.copy_progress(12345)
            >>> status = result["data"]["status"]
            >>> if status == 2:
            ...     print("复制完成")
            >>> elif status == 3:
            ...     print("复制失败")
        """
        return await self._send_request(
            API_PATHS.async_copy_process,
            params={
                "taskId": task_id
            }
        )

    async def recover(self, file_ids: List[int]) -> Dict[str, Any]:
        """
        还原文件
        
        将回收站的文件恢复至删除前的位置。
        如果父级目录不存在，文件ID会返回在abnormalFileIDs中，
        可以使用recover_by_path接口恢复到指定目录。
        
        注意：一次性最大不能超过100个文件。
        
        Args:
            file_ids: 要还原的文件ID数组，最多100个
        
        Returns:
            Dict[str, Any]: API响应数据
            
        Returns Data Structure:
            {
                "code": 0,
                "message": "ok",
                "data": {
                    "abnormalFileIDs": [12345]
                }
            }
        
        Example:
            >>> result = await file_management.recover([12345, 12346])
            >>> abnormal = result["data"]["abnormalFileIDs"]
            >>> if abnormal:
            ...     print("部分文件还原失败，使用recover_by_path")
        """
        return await self._send_request(
            API_PATHS.recover,
            json={
                "fileIDs": file_ids
            }
        )

    async def recover_to(self, file_ids: List[int], parent_file_id: int) -> Dict[str, Any]:
        """
        还原文件到指定目录
        
        将回收站的文件恢复至指定的目录位置。
        
        注意：一次性最大不能超过100个文件。
        
        Args:
            file_ids: 要还原的文件ID数组，最多100个
            parent_file_id: 指定目录ID
        
        Returns:
            Dict[str, Any]: API响应数据
            
        Returns Data Structure:
            {
                "code": 0,
                "message": "ok",
                "data": null
            }
        
        Example:
            >>> result = await file_management.recover_to([12345], 67890)
            >>> if result["code"] == 0:
            ...     print("还原成功")
        """
        return await self._send_request(
            API_PATHS.recover_by_path,
            json={
                "fileIDs": file_ids,
                "parentFileID": parent_file_id
            }
        )

    async def move(self, file_ids: List[int], to_parent_file_id: int) -> Dict[str, Any]:
        """
        移动文件
        
        批量移动文件到指定目录。
        
        注意：单级最多支持100个文件。
        
        Args:
            file_ids: 要移动的文件ID数组，最多100个
            to_parent_file_id: 目标目录ID，移动到根目录时填写0
        
        Returns:
            Dict[str, Any]: API响应数据
            
        Returns Data Structure:
            {
                "code": 0,
                "message": "ok",
                "data": null
            }
        
        Example:
            >>> result = await file_management.move([12345, 12346], 67890)
            >>> if result["code"] == 0:
            ...     print("移动成功")
        """
        return await self._send_request(
            API_PATHS.move,
            json={
                "fileIDs": file_ids,
                "toParentFileID": to_parent_file_id
            }
        )

    async def detail(self, file_id: int) -> Dict[str, Any]:
        """
        获取文件详情
        
        获取指定文件的详细信息。
        支持查询单文件夹包含文件大小。
        
        Args:
            file_id: 文件ID
        
        Returns:
            Dict[str, Any]: API响应数据
            
        Returns Data Structure:
            {
                "code": 0,
                "message": "ok",
                "data": {
                    "fileID": 12345,
                    "filename": "文件名.txt",
                    "type": 0,
                    "size": 1024,
                    "etag": "md5值",
                    "status": 0,
                    "parentFileID": 0,
                    "createAt": "2024-01-01 12:00:00",
                    "trashed": 0
                }
            }
        
        字段说明:
            type: 0-文件, 1-文件夹
            status: 文件审核状态，大于100为审核驳回文件
            trashed: 该文件是否在回收站，0否、1是
        
        Example:
            >>> result = await file_management.detail(12345)
            >>> file_info = result["data"]
            >>> print(f"文件名: {file_info['filename']}")
            >>> print(f"大小: {file_info['size']} 字节")
        """
        return await self._send_request(
            API_PATHS.file_detail,
            params={
                "fileID": file_id
            }
        )
