gangyan/langchain-chat/server/translator_service/converter/docx.py

import os
import asyncio
import re
import shutil
import zipfile
from typing import Callable, Dict, List, Optional, Tuple, Any
from io import BytesIO

from docx import Document
from docx.enum.shape import WD_INLINE_SHAPE_TYPE
from dataclasses import dataclass, field
from lxml import etree as ET  # 替换为 lxml 的 etree

from configs.basic_config import *
from configs.translate_config import *
from server.translator_service.translator.openai_translator import OpenAITranslator

class LLMTranslator:

    def __init__(
        self,
        lang_in: str,
        lang_out: str,
        temp_dict: dict[str, str] = None,
    ) -> None:
        self.lang_in = lang_in if lang_in != "auto" else ""
        self.lang_out = lang_out
        self.translator = OpenAITranslator(
            lang_in=self.lang_in,
            lang_out=self.lang_out,
            model=LLM_MODEL,
            base_url=LLM_ENDPOINT,
            api_key=LLM_API_KEY,
            ignore_cache= True,
            qps=LLM_CONCURRENCY_LIMIT,
        )
        self.vocab = None
    async def translate(self, text: str) -> str:
        if not text:
            return text

        # 如果是数字，则跳过，注意数字内可能包含 . , - 且可能在数字中间
        if re.match(r"^-?\d+([.,\-]\d+)*$", text):
            return text

        # 如果是单个英文字母，无论大小写，直接返回原文
        if re.match(r"^[a-zA-Z]$", text):
            return text

        # 如果是单个标点符号，则跳过
        if text in SYMBOLS:
            return text

        retries = LLM_RETRIES
        while retries > 0:
            try:
                logger.info(f"开始翻译: {text}")
                if text == "之" and self.lang_out == "en":
                    return "Of"
                result = await asyncio.get_event_loop().run_in_executor(
                    None, lambda: self.translator.translate(text)
                )
                logger.info(f"翻译完成: {result}")
                return result.replace("<br>", "\n")
            except Exception as e:
                retries -= 1
                if retries > 0:
                    logger.warning(f"翻译失败,剩余重试次数{retries}: {str(e)}")
                    await asyncio.sleep(1)
                    continue
                logger.error(f"翻译失败且重试次数已用完: {str(e)}")
                return text
            

async def processor(
    input_path: str,
    output_path: str,
    lang_in: str,
    lang_out: str,
    is_dual_language: bool,
    work_dir: str,
    progress_callback: Callable[[float], None],
    cancel_event: Optional[asyncio.Event] = None,
):
    """DOCX文档翻译处理入口函数"""
    docx_translator = DocxTranslator(
        input_path=input_path,
        output_path=output_path,
        lang_in=lang_in,
        lang_out=lang_out,
        is_dual_language=is_dual_language,
        work_dir=work_dir,
        progress_callback=progress_callback,
        cancel_event=cancel_event,
    )
    await docx_translator.initialize()
    await docx_translator.process()


@dataclass
class TranslationTask:
    """翻译任务数据类，用于存储待翻译的文本和对应的元素信息"""

    element: ET.Element  # XML元素
    text_element: Optional[ET.Element] = None  # 主要文本元素
    original_text: str = ""  # 原始文本
    translated_text: Optional[str] = None  # 翻译后的文本
    is_dual_language: bool = False  # 是否为双语模式
    text_elements: List[ET.Element] = field(default_factory=list)  # 所有相关文本元素
    number_text: str = ""  # 目录项的编号部分
    page_text: str = ""  # 目录项的页码部分
    is_toc: bool = False  # 是否为目录项
    page_number: str = ""  # 目录项的页码部分
    comment_id: Optional[str] = None
    revision_id: Optional[str] = None
    is_comment: bool = False
    is_revision: bool = False
    comments: List[Tuple[str, ET.Element]] = field(
        default_factory=list
    )  # 批注文本和元素对的列表
    revisions: List[Tuple[str, ET.Element]] = field(
        default_factory=list
    )  # 修订记录文本和元素对的列表
    text_map: List[Tuple[str, str, ET.Element]] = field(
        default_factory=list
    )  # 用于存储文本片段和其对应的元素信息

    def __post_init__(self):
        if self.text_element and not self.text_elements:
            self.text_elements = [self.text_element]


class DocxTranslator:
    """DOCX文档翻译器

    负责处理DOCX文档的翻译。
    支持单语和双语模式。
    """

    # XML命名空间
    ns = {
        "w": "http://schemas.openxmlformats.org/wordprocessingml/2006/main",
        "m": "http://schemas.openxmlformats.org/officeDocument/2006/math",
        "w14": "http://schemas.microsoft.com/office/word/2010/wordml",
    }

    def __init__(
        self,
        input_path: str,
        output_path: str,
        lang_in: str,
        lang_out: str,
        is_dual_language: bool,
        work_dir: str,
        progress_callback: Callable[[float], None],
        cancel_event: Optional[asyncio.Event] = None,
    ):
        """初始化文档翻译器

        Args:
            input_path: 输入文档路径
            output_path: 输出文档路径
            lang_in: 输入语言
            lang_out: 输出语言
            is_dual_language: 是否使用双语模式
            work_dir: 工作目录
            progress_callback: 进度回调函数
            cancel_event: 取消事件
        """
        # 文件路径相关
        self.input_path = input_path
        self.output_path = output_path
        self.work_dir = work_dir
        self.doc_dir = os.path.join(work_dir, "doc")
        self.img_dir = os.path.join(work_dir, "img")

        # 翻译配置
        self.lang_in = lang_in
        self.lang_out = lang_out
        self.is_dual_language = is_dual_language
        # 进度和控制
        self.progress_callback = progress_callback
        self.cancel_event = cancel_event
        self.total_items = 0
        self.processed_items = 0

        # 翻译引擎
        self.llm_translator = None
        self.image_processor = None

        # 文档对象
        self.doc = None
        self.doc_tree = None
        self.doc_root = None
        self.doc_xml_path = None

        # 锁
        self.doc_lock = asyncio.Lock()
        self.progress_lock = asyncio.Lock()

        # 批注和修订记录相关
        self.comments_tasks = []
        self.revision_tasks = []

        # 页眉页脚相关
        self.header_tasks = []
        self.footer_tasks = []

        # 目录项相关
        self.toc_tasks = []

    # ===== 初始化和主流程方法 =====

    async def initialize(self):
        """初始化翻译器和工作环境"""
        await self.check_cancelled()

        # 加载文档
        loop = asyncio.get_event_loop()
        self.doc = await loop.run_in_executor(None, lambda: Document(self.input_path))

        # 初始化翻译引擎
        logger.info(
            f"初始化翻译器 - 输入语言: {self.lang_in}, 输出语言: {self.lang_out}"
        )
        self.llm_translator = LLMTranslator(
            lang_in=self.lang_in,
            lang_out=self.lang_out,
        )

        # 准备工作目录
        await self._prepare_work_directories()

        # 解析文档XML
        await self._extract_and_parse_document()

        # 计算总项目数
        await self._calculate_total_items()

        await self.check_cancelled()

    async def process(self):
        """处理文档翻译的主流程"""
        try:
            await self.check_cancelled()

            # 收集所有需要翻译的内容
            await self.collect_all_content()

            # 翻译文档文本
            await self.translate_document()

            # 翻译批注和修订记录
            await self.translate_comments_and_revisions()

            # 翻译页眉页脚
            await self.translate_headers_and_footers()

            await self.check_cancelled()

            # 保存处理后的文档
            await self.save_document()

        except asyncio.CancelledError:
            logger.info("任务被取消，正在退出...")
            raise
        except Exception as e:
            logger.error(f"处理文档失败: {str(e)}")
            raise
        finally:
            # 清理资源
            await self.cleanup()

    # ===== 文档处理辅助方法 =====

    async def _prepare_work_directories(self):
        """准备工作目录"""
        if os.path.exists(self.work_dir):
            shutil.rmtree(self.work_dir)
        os.makedirs(self.work_dir, exist_ok=True)
        os.makedirs(self.doc_dir, exist_ok=True)
        os.makedirs(self.img_dir, exist_ok=True)

    async def _extract_and_parse_document(self):
        """解压并解析文档XML，使用lxml"""
        try:
            with zipfile.ZipFile(self.input_path, "r") as zip_ref:
                zip_ref.extractall(self.doc_dir)
        except Exception as e:
            logger.error(f"解压文档失败: {str(e)}")
            raise

        try:
            self.doc_xml_path = os.path.join(self.doc_dir, "word", "document.xml")
            parser = ET.XMLParser(remove_blank_text=True)
            self.doc_tree = ET.parse(self.doc_xml_path, parser)
            self.doc_root = self.doc_tree.getroot()
        except Exception as e:
            logger.error(f"解析文档失败: {str(e)}")
            raise

    async def _calculate_total_items(self):
        """计算需要处理的总项目数"""
        # 原有的文档元素计数
        doc_elements = self.doc_root.findall(".//w:p", self.ns)
        doc_tables = self.doc_root.findall(".//w:tbl", self.ns)

        # 添加页眉页脚、批注和修订记录的计数
        total_headers = len(self.header_tasks)
        total_footers = len(self.footer_tasks)
        total_comments = len(self.comments_tasks)
        total_revisions = len(self.revision_tasks)
        total_toc_entries = len(self.toc_tasks)

        # 更新总项目数
        self.total_items = (
            len(doc_elements)
            + len(doc_tables)
            + total_headers
            + total_footers
            + total_comments
            + total_revisions
            + total_toc_entries
        )

        logger.info(f"文档中共有 {self.total_items} 个文本元素需要处理")

    # ===== 文本翻译相关方法 =====

    async def translate_document(self):
        """翻译文档文本内容，使用并发方式处理"""
        try:
            # 创建任务列表
            tasks = []

            # 收集需要翻译的段落
            for element in self.doc_root.findall(".//w:p", self.ns):
                # 如果元素包含数学公式，则跳过
                if any(
                    child.tag.startswith("{" + self.ns["m"] + "}")
                    for child in element.iter()
                ):
                    continue

                # 检查是否是目录项，如果是则跳过（由专门的方法处理）
                if any(task.element == element for task in self.toc_tasks):
                    continue

                if self.is_dual_language:
                    # 双语模式：收集整个元素的文本
                    await self.collect_dual_language_task(element, tasks)
                else:
                    # 单语模式：收集每个Run的文本
                    await self.collect_single_language_tasks(element, tasks)

                # 当收集到足够的任务或处理完所有元素时，执行批量翻译
                if len(tasks) >= LLM_CONCURRENCY_LIMIT:
                    await self.process_translation_batch(tasks)
                    tasks = []  # 清空任务列表

            # 处理剩余的任务
            if tasks:
                await self.process_translation_batch(tasks)

            # 处理目录项
            if self.toc_tasks:
                await self.translate_toc_entries()

        except Exception as e:
            logger.error(f"处理文档文本失败: {str(e)}")
            raise

    async def collect_dual_language_task(
        self, element: ET.Element, tasks: List[TranslationTask]
    ) -> None:
        """收集双语模式下的翻译任务

        Args:
            element: XML元素
            tasks: 任务列表
        """
        # 提取文本
        text = []
        for t in element.iter("{" + self.ns["w"] + "}t"):
            if t.text:
                text.append(t.text)

        original_text = "".join(text).strip()

        # 如果有文本需要翻译，添加到任务列表
        if original_text:
            task = TranslationTask(
                element=element, original_text=original_text, is_dual_language=True
            )
            tasks.append(task)

    async def collect_single_language_tasks(
        self, element: ET.Element, tasks: List[TranslationTask]
    ) -> None:
        """收集单语模式下的翻译任务，批注和修订记录只收集不添加内容"""
        text_elements = list(element.iter("{" + self.ns["w"] + "}t"))
        if not text_elements:
            return

        # 收集主文本（包含修订记录的内容）
        main_text = "".join(t.text or "" for t in text_elements)

        # 收集批注和修订记录（只收集引用，不添加内容）
        comments = []
        revisions = []

        # 收集批注
        for comment_ref in element.findall(".//w:commentReference", self.ns):
            comment_id = comment_ref.get("{" + self.ns["w"] + "}id")
            comment_xml = os.path.join(self.doc_dir, "word", "comments.xml")
            if os.path.exists(comment_xml):
                comment_tree = ET.parse(comment_xml)
                comment_root = comment_tree.getroot()
                comment = comment_root.find(
                    f".//w:comment[@w:id='{comment_id}']", self.ns
                )
                if comment is not None:
                    comments.append(comment)

        # 收集修订记录（只收集引用）
        for revision in element.findall(".//w:del", self.ns) + element.findall(
            ".//w:ins", self.ns
        ):
            revisions.append(revision)

        if main_text.strip():
            task = TranslationTask(
                element=element,
                text_elements=text_elements,  # 包含所有文本元素
                original_text=main_text,
                is_dual_language=False,
                comments=comments,
                revisions=revisions,
            )
            tasks.append(task)

    async def process_translation_batch(self, tasks: List[TranslationTask]) -> None:
        """并发处理一批翻译任务

        Args:
            tasks: 翻译任务列表
        """
        await self.check_cancelled()

        # 创建翻译协程列表
        translation_coroutines = []
        for task in tasks:
            if task.original_text:
                translation_coroutines.append(self.translate_text(task))

        # 并发执行翻译
        if translation_coroutines:
            await asyncio.gather(*translation_coroutines)

        # 更新文档
        for task in tasks:
            if task.translated_text:
                if task.is_dual_language:
                    await self.update_dual_language_element(task)
                else:
                    await self.update_single_language_element(task)

            # 更新进度
            await self.update_progress()

    async def translate_text(self, task: TranslationTask) -> None:
        """翻译单个文本

        Args:
            task: 翻译任务
        """
        try:
            await self.check_cancelled()
            # 实际调用翻译API
            translated_text = await self.llm_translator.translate(task.original_text)
            # translated_text = "X" + task.original_text + "X"
            # 如果翻译失败，保留原文
            if not translated_text or translated_text == "error":
                translated_text = task.original_text
            task.translated_text = translated_text
        except Exception as e:
            logger.error(f"翻译文本失败: {str(e)}")
            task.translated_text = task.original_text

    async def update_dual_language_element(self, task: TranslationTask) -> None:
        """更新双语模式下的元素文本"""
        # 获取原始段落在文档中的位置
        all_paragraphs = self.doc_root.findall(".//w:p", self.ns)
        try:
            index = all_paragraphs.index(task.element)
        except ValueError:
            # 如果找不到元素，则使用原来的双语模式
            dual_text = f"{task.original_text} ({task.translated_text})"
            text_elements = list(task.element.iter("{" + self.ns["w"] + "}t"))
            if text_elements:
                text_elements[0].text = dual_text
            return

        # 检查原段落是否整段都有加粗
        is_all_bold = True
        runs = task.element.findall(".//w:r", self.ns)
        for run in runs:
            # 检查run是否包含文本
            if run.find(".//w:t", self.ns) is not None:
                # 检查是否有加粗属性
                rPr = run.find(".//w:rPr", self.ns)
                if rPr is None or rPr.find(".//w:b", self.ns) is None:
                    is_all_bold = False
                    break

        # 复制原始段落创建新段落
        new_paragraph = ET.fromstring(ET.tostring(task.element))

        # 清除新段落中的所有文本
        for t_element in new_paragraph.findall(".//w:t", self.ns):
            t_element.text = ""

        # 找到第一个文本元素并设置为译文
        text_elements = list(new_paragraph.findall(".//w:t", self.ns))
        if text_elements:
            # 设置译文
            text_elements[0].text = task.translated_text
            
            # 设置译文格式
            run = text_elements[0].getparent()  # 获取包含文本的run元素
            if run is not None:
                # 获取或创建rPr元素
                rPr = run.find(".//w:rPr", self.ns)
                if rPr is None:
                    rPr = ET.SubElement(run, "{" + self.ns["w"] + "}rPr")
                
                # 根据原文格式设置译文加粗
                if is_all_bold:
                    # 添加加粗标记
                    if rPr.find(".//w:b", self.ns) is None:
                        ET.SubElement(rPr, "{" + self.ns["w"] + "}b")
                else:
                    # 移除加粗标记
                    bold = rPr.find(".//w:b", self.ns)
                    if bold is not None:
                        rPr.remove(bold)

        # 找到原段落的父元素
        parent = None
        for elem in self.doc_root.iter():
            if task.element in list(elem):
                parent = elem
                break

        if parent is not None:
            # 在原段落后插入新段落
            parent_children = list(parent)
            index_in_parent = parent_children.index(task.element)
            parent.insert(index_in_parent + 1, new_paragraph)
        else:
            # 如果找不到父元素，则使用原来的双语模式
            dual_text = f"{task.original_text} ({task.translated_text})"
            text_elements = list(task.element.iter("{" + self.ns["w"] + "}t"))
            if text_elements:
                text_elements[0].text = dual_text

    def _smart_split_text(self, text: str) -> List[str]:
        """智能分割翻译后的文本，考虑标点符号和自然语言边界

        Args:
            text: 要分割的文本

        Returns:
            分割后的文本片段列表
        """
        # 定义分割标记
        delimiters = list(SYMBOLS) + [" "]

        # 如果文本很短，直接返回
        if len(text) <= 10:
            return [text]

        segments = []
        current_segment = ""

        for char in text:
            current_segment += char

            # 在分隔符处进行分割
            if any(current_segment.endswith(d) for d in delimiters):
                segments.append(current_segment)
                current_segment = ""

        # 处理剩余文本
        if current_segment:
            segments.append(current_segment)

        return segments

    async def update_single_language_element(self, task: TranslationTask) -> None:
        """更新单语模式下的元素文本"""
        if not task.translated_text:
            return

        # 检查原段落是否整段都有加粗
        is_all_bold = True
        runs = task.element.findall(".//w:r", self.ns)
        for run in runs:
            # 检查run是否包含文本
            if run.find(".//w:t", self.ns) is not None:
                # 检查是否有加粗属性
                rPr = run.find(".//w:rPr", self.ns)
                if rPr is None or rPr.find(".//w:b", self.ns) is None:
                    is_all_bold = False
                    break

        # 更新主文本
        if task.text_elements:
            # 设置第一个文本元素的内容
            task.text_elements[0].text = task.translated_text
            
            # 设置译文格式
            run = task.text_elements[0].getparent()  # 获取包含文本的run元素
            if run is not None:
                # 获取或创建rPr元素
                rPr = run.find(".//w:rPr", self.ns)
                if rPr is None:
                    rPr = ET.SubElement(run, "{" + self.ns["w"] + "}rPr")
                
                # 根据原文格式设置译文加粗
                if is_all_bold:
                    # 添加加粗标记
                    if rPr.find(".//w:b", self.ns) is None:
                        ET.SubElement(rPr, "{" + self.ns["w"] + "}b")
                else:
                    # 移除加粗标记
                    bold = rPr.find(".//w:b", self.ns)
                    if bold is not None:
                        rPr.remove(bold)
            
            # 清空其他文本元素
            for t in task.text_elements[1:]:
                t.text = ""

    async def translate_element_dual(self, element: ET.Element) -> None:
        """双语模式：提取并翻译整个元素的文本（保留此方法以兼容现有代码）

        Args:
            element: XML元素
        """
        # 如果元素包含数学公式，则跳过
        if any(
            child.tag.startswith("{" + self.ns["m"] + "}") for child in element.iter()
        ):
            return

        # 提取文本
        text = []
        for t in element.iter("{" + self.ns["w"] + "}t"):
            if t.text:
                text.append(t.text)

        original_text = "".join(text).strip()

        # 翻译文本
        if original_text:
            try:
                await self.check_cancelled()
                # 实际应用中调用翻译API
                translated_text = await self.llm_translator.translate(original_text)
                # translated_text = "X" + original_text + "X"
                # 如果翻译失败，保留原文
                if not translated_text or translated_text == "error":
                    translated_text = original_text
            except Exception as e:
                logger.error(f"翻译文本失败: {str(e)}")
                translated_text = original_text

            # 构建双语文本（原文 + 译文）
            dual_text = f"{original_text}\n{translated_text}"

            # 更新文本
            text_elements = list(element.iter("{" + self.ns["w"] + "}t"))
            if not text_elements:
                return

            if len(text_elements) == 1:
                text_elements[0].text = dual_text
                return

            # 处理多个文本元素的情况
            # 首先保留第一个元素的原文
            first_element = text_elements[0]
            first_element.text = original_text + "\n"

            # 然后将译文分配给剩余的元素
            words = translated_text.split()
            total_words = len(words)
            remaining_elements = text_elements[1:]

            if not remaining_elements:
                # 如果只有一个元素，则将译文附加到原文后
                first_element.text = dual_text
                return

            words_per_element = max(1, total_words // len(remaining_elements))

            for i, t_element in enumerate(remaining_elements):
                start_idx = i * words_per_element
                end_idx = (
                    start_idx + words_per_element
                    if i < len(remaining_elements) - 1
                    else None
                )
                if start_idx < len(words):
                    t_element.text = " ".join(words[start_idx:end_idx])
                else:
                    t_element.text = ""

            # 更新进度
            await self.update_progress()

    async def translate_element_single(self, element: ET.Element) -> None:
        """单语模式：按每个Run单独翻译段落中的文本（保留此方法以兼容现有代码）

        Args:
            element: XML元素
        """
        # 如果元素包含数学公式，则跳过
        if any(
            child.tag.startswith("{" + self.ns["m"] + "}") for child in element.iter()
        ):
            return

        # 获取所有文本元素
        text_elements = list(element.iter("{" + self.ns["w"] + "}t"))
        if not text_elements:
            return

        # 对每个文本元素单独处理
        for t_element in text_elements:
            if t_element.text and t_element.text.strip():
                original_text = t_element.text
                # 实际应用中调用翻译API
                try:
                    await self.check_cancelled()
                    translated_text = await self.llm_translator.translate(original_text)
                    # translated_text = "X" + original_text + "X"
                    # 如果翻译失败，保留原文
                    if not translated_text or translated_text == "error":
                        translated_text = original_text
                except Exception as e:
                    logger.error(f"翻译文本失败: {str(e)}")
                    translated_text = original_text

                t_element.text = translated_text

        # 更新进度
        await self.update_progress()

    # ===== 文档保存和清理方法 =====

    async def save_document(self):
        """保存处理后的文档"""
        async with self.doc_lock:
            await self.check_cancelled()

            # 首先保存 XML 更改
            self.doc_tree.write(
                self.doc_xml_path, encoding="UTF-8", xml_declaration=True
            )

            # 然后打包所有文件到新的 docx
            with zipfile.ZipFile(self.output_path, "w") as outzip:
                for foldername, subfolders, filenames in os.walk(self.doc_dir):
                    for filename in filenames:
                        file_path = os.path.join(foldername, filename)
                        arcname = os.path.relpath(file_path, self.doc_dir)
                        outzip.write(file_path, arcname)
            # 文档处理完成后，设置进度为100%
            self.progress_callback(100.0)

    # async def save_document_by_docx(self):
    #     """用 python-docx 库保存处理后的文档"""
    #     async with self.doc_lock:
    #         await self.check_cancelled()
    #         loop = asyncio.get_event_loop()
    #         await loop.run_in_executor(None, lambda: self.doc.save(self.output_path))
    #         # 文档处理完成后，设置进度为100%
    #         self.progress_callback(100.0)

    async def cleanup(self):
        """清理资源和临时文件"""
        # 清理内存资源
        await self.cleanmem()

        # 清理临时文件
        if os.path.exists(self.work_dir):
            shutil.rmtree(self.work_dir)

        logger.info("资源和临时文件清理完成")

    async def cleanmem(self):
        """清理内存资源"""
        if self.llm_translator:
            del self.llm_translator
        if self.image_processor:
            del self.image_processor
        if self.doc:
            del self.doc
        logger.info("内存资源清理完成")

    # ===== 工具方法 =====

    async def check_cancelled(self):
        """检查任务是否被取消"""
        if self.cancel_event and self.cancel_event.is_set():
            logger.info("任务被取消，正在退出...")
            raise asyncio.CancelledError("任务已被取消")

    async def update_progress(self):
        """更新处理进度"""
        await self.check_cancelled()
        self.processed_items += 1
        progress = (
            min(100.0, (self.processed_items / self.total_items) * 100)
            if self.total_items > 0
            else 0
        )
        self.progress_callback(progress)

    async def collect_all_content(self):
        """收集所有需要翻译的内容"""
        # 收集批注和修订记录
        await self.collect_comments_and_revisions()

        # 收集页眉页脚
        await self.collect_headers_and_footers()

        # 收集目录项
        await self.collect_toc_entries()

    async def collect_headers_and_footers(self):
        """收集页眉页脚内容"""
        # 处理页眉
        for section_id in range(1, 10):  # 通常文档不会超过9个节
            header_xml = os.path.join(self.doc_dir, "word", f"header{section_id}.xml")
            if os.path.exists(header_xml):
                tree = ET.parse(header_xml)
                root = tree.getroot()

                for paragraph in root.findall(".//w:p", self.ns):
                    text = "".join(
                        t.text
                        for r in paragraph.findall(".//w:r", self.ns)
                        for t in r.findall(".//w:t", self.ns)
                        if t.text
                    )
                    if text.strip():
                        self.header_tasks.append(
                            TranslationTask(
                                element=paragraph,
                                original_text=text,
                                is_dual_language=self.is_dual_language,
                                text_elements=[
                                    t
                                    for r in paragraph.findall(".//w:r", self.ns)
                                    for t in r.findall(".//w:t", self.ns)
                                ],
                            )
                        )

        # 处理页脚
        for section_id in range(1, 10):
            footer_xml = os.path.join(self.doc_dir, "word", f"footer{section_id}.xml")
            if os.path.exists(footer_xml):
                tree = ET.parse(footer_xml)
                root = tree.getroot()

                for paragraph in root.findall(".//w:p", self.ns):
                    text = "".join(
                        t.text
                        for r in paragraph.findall(".//w:r", self.ns)
                        for t in r.findall(".//w:t", self.ns)
                        if t.text
                    )
                    if text.strip():
                        self.footer_tasks.append(
                            TranslationTask(
                                element=paragraph,
                                original_text=text,
                                is_dual_language=self.is_dual_language,
                                text_elements=[
                                    t
                                    for r in paragraph.findall(".//w:r", self.ns)
                                    for t in r.findall(".//w:t", self.ns)
                                ],
                            )
                        )

    async def collect_comments_and_revisions(self):
        """收集批注和修订记录内容"""
        # 处理批注
        comments_xml = os.path.join(self.doc_dir, "word", "comments.xml")
        if os.path.exists(comments_xml):
            tree = ET.parse(comments_xml)
            root = tree.getroot()

            for comment in root.findall(".//w:comment", self.ns):
                text = []
                runs = comment.findall(".//w:r", self.ns)
                for i, r in enumerate(runs):
                    for t in r.findall(".//w:t", self.ns):
                        if t.text:
                            text.append(t.text)
                    # 检查是否需要在运行元素之间添加空格
                    if i < len(runs) - 1:  # 如果不是最后一个运行元素
                        next_run = runs[i + 1]
                        if next_run.find(".//w:t", self.ns) is not None:
                            text.append(" ")

                text = "".join(text).strip()
                if text:
                    self.comments_tasks.append(
                        TranslationTask(
                            element=comment,
                            original_text=text,
                            is_dual_language=self.is_dual_language,
                            text_elements=[
                                t
                                for r in comment.findall(".//w:r", self.ns)
                                for t in r.findall(".//w:t", self.ns)
                            ],
                            is_comment=True,
                            comment_id=comment.get("{" + self.ns["w"] + "}id"),
                        )
                    )

        # 处理修订记录
        for element in self.doc_root.findall(
            ".//w:del", self.ns
        ) + self.doc_root.findall(".//w:ins", self.ns):
            text = []
            runs = element.findall(".//w:r", self.ns)
            for i, r in enumerate(runs):
                for t in r.findall(".//w:t", self.ns):
                    if t.text:
                        text.append(t.text)
                # 检查是否需要在运行元素之间添加空格
                if i < len(runs) - 1:  # 如果不是最后一个运行元素
                    next_run = runs[i + 1]
                    if next_run.find(".//w:t", self.ns) is not None:
                        text.append(" ")

            text = "".join(text).strip()
            if text:
                self.revision_tasks.append(
                    TranslationTask(
                        element=element,
                        original_text=text,
                        is_dual_language=self.is_dual_language,
                        text_elements=[
                            t
                            for r in element.findall(".//w:r", self.ns)
                            for t in r.findall(".//w:t", self.ns)
                        ],
                        is_revision=True,
                        revision_id=element.get("{" + self.ns["w"] + "}id"),
                    )
                )

    async def collect_toc_entries(self):
        """收集目录项内容并特殊处理"""
        # 查找所有可能的目录段落
        toc_paragraphs = []

        # 首先找到所有段落
        all_paragraphs = self.doc_root.findall(".//w:p", self.ns)

        # 然后筛选包含目录特征的段落
        for paragraph in all_paragraphs:
            # 获取段落的完整文本
            full_text = "".join(
                t.text or ""
                for t in paragraph.findall(".//w:t", self.ns)
            ).strip()
            
            # 检查段落长度和末尾字符
            if len(full_text) > 255:
                continue
            
            # 检查是否包含制表符和末尾是否为数字
            has_tab = paragraph.find(".//w:tab", self.ns) is not None
            ends_with_digit = full_text and full_text[-1].isdigit()

            if has_tab and ends_with_digit:
                toc_paragraphs.append(paragraph)

        for paragraph in toc_paragraphs:
            # 分析段落结构，识别标题文本、分隔符和页码
            runs = paragraph.findall(".//w:r", self.ns)

            # 收集所有文本元素和它们的位置信息
            text_elements = []
            tab_elements = []
            page_number_elements = []

            for i, r in enumerate(runs):
                # 检查是否包含制表符
                if r.find(".//w:tab", self.ns) is not None:
                    tab_elements.append((i, r))
                    continue

                # 获取文本
                t_elements = r.findall(".//w:t", self.ns)
                for t in t_elements:
                    if t.text:
                        # 检查是否可能是页码（纯数字且位于段落末尾）
                        if t.text.strip().isdigit() and i > len(runs) * 0.7:
                            page_number_elements.append((i, r, t))
                        else:
                            text_elements.append((i, r, t))

            # 如果找到了文本和页码，创建翻译任务
            if text_elements and page_number_elements:
                # 提取标题文本
                title_text = "".join(t.text for _, _, t in text_elements)

                # 创建翻译任务
                task = TranslationTask(
                    element=paragraph,
                    original_text=title_text.strip(),
                    is_dual_language=False,
                    text_elements=[t for _, _, t in text_elements],
                )

                # 添加结构信息
                task.is_toc_entry = True
                task.page_number_elements = page_number_elements
                task.tab_elements = tab_elements
                task.original_structure = {
                    "text": text_elements,
                    "tabs": tab_elements,
                    "page_numbers": page_number_elements,
                }

                self.toc_tasks.append(task)

    async def translate_toc_entries(self):
        """翻译目录项，保留特殊格式"""
        if not self.toc_tasks:
            return

        # 创建翻译协程列表
        translation_coroutines = []
        for task in self.toc_tasks:
            if task.original_text:
                translation_coroutines.append(self.translate_text(task))

        # 并发执行翻译
        if translation_coroutines:
            await asyncio.gather(*translation_coroutines)

        # 更新目录项
        for task in self.toc_tasks:
            if task.translated_text:
                # 特殊处理目录项的更新，保留页码和分隔符
                await self.update_toc_entry(task)

            # 更新进度
            await self.update_progress()

    async def update_toc_entry(self, task: TranslationTask) -> None:
        """特殊更新目录项，保留页码和分隔符格式

        Args:
            task: 翻译任务
        """
        if not task.text_elements or not hasattr(task, "original_structure"):
            return

        # 获取原始结构信息
        original_structure = task.original_structure

        # 1. 清空所有文本元素
        for t in task.text_elements:
            t.text = ""

        # 2. 根据是否为双语模式处理文本
        if task.text_elements:
            if self.is_dual_language:
                # 双语模式：原文 (译文)
                task.text_elements[
                    0
                ].text = f"{task.original_text} ({task.translated_text})"
            else:
                # 单语模式：仅译文
                task.text_elements[0].text = task.translated_text

        # 3. 确保只保留一个制表符，删除多余的制表符
        if hasattr(task, "tab_elements") and task.tab_elements:
            # 只保留最后一个制表符，删除其他制表符
            for i, (idx, tab) in enumerate(task.tab_elements[:-1]):
                parent = tab.getparent()
                if parent is not None:
                    parent.remove(tab)

        # 4. 确保页码元素保持在原位置
        if hasattr(task, "page_number_elements") and task.page_number_elements:
            # 页码元素保持不变
            pass

    async def translate_comments_and_revisions(self):
        """翻译批注和修订记录"""
        # 翻译批注
        if self.comments_tasks:
            await self.process_translation_batch(self.comments_tasks)

            # 更新批注XML
            comments_xml = os.path.join(self.doc_dir, "word", "comments.xml")
            if os.path.exists(comments_xml):
                tree = ET.parse(comments_xml)
                root = tree.getroot()

                for task in self.comments_tasks:
                    if task.translated_text:
                        comment = root.find(
                            f".//w:comment[@w:id='{task.comment_id}']", self.ns
                        )
                        if comment is not None:
                            # 更新批注文本
                            for t in comment.findall(".//w:t", self.ns):
                                t.text = task.translated_text

                tree.write(comments_xml, encoding="UTF-8", xml_declaration=True)

        # 翻译修订记录
        if self.revision_tasks:
            await self.process_translation_batch(self.revision_tasks)

            # 更新修订记录
            for task in self.revision_tasks:
                if task.translated_text:
                    # 为修订记录的译文添加括号
                    bracketed_translation = f"({task.translated_text})"
                    for t in task.element.findall(".//w:t", self.ns):
                        t.text = bracketed_translation

    async def translate_headers_and_footers(self):
        """翻译页眉页脚内容"""
        # 翻译页眉
        if self.header_tasks:
            await self.process_translation_batch(self.header_tasks)

            # 更新页眉XML
            for section_id in range(1, 10):
                header_xml = os.path.join(
                    self.doc_dir, "word", f"header{section_id}.xml"
                )
                if os.path.exists(header_xml):
                    tree = ET.parse(header_xml)
                    root = tree.getroot()

                    # 更新翻译后的文本
                    for task in self.header_tasks:
                        if task.translated_text:
                            # 查找对应的段落
                            for paragraph in root.findall(".//w:p", self.ns):
                                # 比较段落内容以确认是否是正确的段落
                                original_text = "".join(
                                    t.text
                                    for r in paragraph.findall(".//w:r", self.ns)
                                    for t in r.findall(".//w:t", self.ns)
                                    if t.text
                                ).strip()

                                if original_text == task.original_text:
                                    # 更新段落中的所有文本元素
                                    text_elements = [
                                        t
                                        for r in paragraph.findall(".//w:r", self.ns)
                                        for t in r.findall(".//w:t", self.ns)
                                    ]

                                    if text_elements:
                                        # 清除其他文本元素
                                        for t in text_elements[1:]:
                                            t.text = ""
                                        # 设置第一个文本元素的内容
                                        text_elements[0].text = task.translated_text

                                        # 确保保留空格属性
                                        if any(
                                            t.get(
                                                "{http://www.w3.org/XML/1998/namespace}space"
                                            )
                                            == "preserve"
                                            for t in text_elements
                                        ):
                                            text_elements[0].set(
                                                "{http://www.w3.org/XML/1998/namespace}space",
                                                "preserve",
                                            )

                    tree.write(header_xml, encoding="UTF-8", xml_declaration=True)

        # 翻译页脚
        if self.footer_tasks:
            await self.process_translation_batch(self.footer_tasks)

            # 更新页脚XML
            for section_id in range(1, 10):
                footer_xml = os.path.join(
                    self.doc_dir, "word", f"footer{section_id}.xml"
                )
                if os.path.exists(footer_xml):
                    tree = ET.parse(footer_xml)
                    root = tree.getroot()

                    # 更新翻译后的文本
                    for task in self.footer_tasks:
                        if task.translated_text:
                            # 查找对应的段落
                            for paragraph in root.findall(".//w:p", self.ns):
                                # 比较段落内容以确认是否是正确的段落
                                original_text = "".join(
                                    t.text
                                    for r in paragraph.findall(".//w:r", self.ns)
                                    for t in r.findall(".//w:t", self.ns)
                                    if t.text
                                ).strip()

                                if original_text == task.original_text:
                                    # 更新段落中的所有文本元素
                                    text_elements = [
                                        t
                                        for r in paragraph.findall(".//w:r", self.ns)
                                        for t in r.findall(".//w:t", self.ns)
                                    ]

                                    if text_elements:
                                        # 清除其他文本元素
                                        for t in text_elements[1:]:
                                            t.text = ""
                                        # 设置第一个文本元素的内容
                                        text_elements[0].text = task.translated_text

                                        # 确保保留空格属性
                                        if any(
                                            t.get(
                                                "{http://www.w3.org/XML/1998/namespace}space"
                                            )
                                            == "preserve"
                                            for t in text_elements
                                        ):
                                            text_elements[0].set(
                                                "{http://www.w3.org/XML/1998/namespace}space",
                                                "preserve",
                                            )

                    tree.write(footer_xml, encoding="UTF-8", xml_declaration=True)