DoLuEdu-WordFileParse/scripts/omml_mathml2latex/visitors/mtd_visitor.py

r"""
Visitor for <mtd> (table cell) MathML elements.

The <mtd> element represents a cell in a table/matrix row. It is a helper
element that contains the actual mathematical content.

This visitor is primarily used by MtrVisitor to convert table cells.
"""

from lxml import etree as ET
from ..core.interfaces import Visitor, Strategy
from ..utils import local_name as _local, text_content as _text_content


class MtdVisitor(Visitor):
    r"""
    Handles <mtd> (table cell) MathML elements.

    Converts table cells to LaTeX format by rendering all child content.

    Examples:
        Simple number:
            <mtd><mn>5</mn></mtd>
            → 5

        Variable:
            <mtd><mi>x</mi></mtd>
            → x

        Expression:
            <mtd><mi>x</mi><mo>+</mo><mn>1</mn></mtd>
            → x+1

        Fraction:
            <mtd><mfrac><mn>1</mn><mn>2</mn></mfrac></mtd>
            → \frac{1}{2}

        Empty cell:
            <mtd></mtd>
            → (empty string)
    """

    def __init__(self, strategy: Strategy):
        """Initialize the Mtd visitor."""
        super().__init__(strategy)

    def visit(self, node: ET.Element) -> str:
        r"""
        Convert <mtd> element to LaTeX.

        Args:
            node: The <mtd> element to convert

        Returns:
            LaTeX string for cell content

        Raises:
            ValueError: If node is not an <mtd> element
        """
        if not self.can_handle(node):
            raise ValueError(f"MtdVisitor cannot handle element '{node.tag}'")

        # Convert all children of the cell
        # Cells are transparent containers, so just render children
        # Join with spaces (like mrow) to ensure proper spacing between elements
        parts = []
        for child in node:
            part = self._convert_child(child)
            if part:  # Only add non-empty parts
                parts.append(part)
        return ' '.join(parts).strip()

    def _convert_child(self, child: ET.Element) -> str:
        """Convert a child element to LaTeX."""
        tag = _local(child.tag)

        # Import visitors as needed to avoid circular imports
        if tag == 'mi':
            from .mi_visitor import MiVisitor
            return MiVisitor(self.strategy).visit(child)
        elif tag == 'mo':
            from .mo_visitor import MoVisitor
            return MoVisitor(self.strategy).visit(child)
        elif tag == 'mn':
            from .mn_visitor import MnVisitor
            return MnVisitor(self.strategy).visit(child)
        elif tag == 'mfrac':
            from .mfrac_visitor import MfracVisitor
            return MfracVisitor(self.strategy).visit(child)
        elif tag == 'msup':
            from .msup_visitor import MsupVisitor
            return MsupVisitor(self.strategy).visit(child)
        elif tag == 'msub':
            from .msub_visitor import MsubVisitor
            return MsubVisitor(self.strategy).visit(child)
        elif tag == 'mrow':
            from .mrow_visitor import MrowVisitor
            return MrowVisitor(self.strategy).visit(child)
        elif tag == 'msqrt':
            from .msqrt_visitor import MsqrtVisitor
            return MsqrtVisitor(self.strategy).visit(child)
        elif tag == 'mroot':
            from .mroot_visitor import MrootVisitor
            return MrootVisitor(self.strategy).visit(child)
        elif tag == 'msubsup':
            from .msubsup_visitor import MsubsupVisitor
            return MsubsupVisitor(self.strategy).visit(child)
        elif tag == 'munder':
            from .munder_visitor import MunderVisitor
            return MunderVisitor(self.strategy).visit(child)
        elif tag == 'mover':
            from .mover_visitor import MoverVisitor
            return MoverVisitor(self.strategy).visit(child)
        elif tag == 'munderover':
            from .munderover_visitor import MunderoverVisitor
            return MunderoverVisitor(self.strategy).visit(child)
        elif tag == 'mfenced':
            from .mfenced_visitor import MfencedVisitor
            return MfencedVisitor(self.strategy).visit(child)
        elif tag == 'mtable':
            from .mtable_visitor import MtableVisitor
            return MtableVisitor(self.strategy).visit(child)
        elif tag == 'mtext':
            from .mtext_visitor import MtextVisitor
            return MtextVisitor(self.strategy).visit(child)
        elif tag == 'mstyle':
            from .mstyle_visitor import MstyleVisitor
            return MstyleVisitor(self.strategy).visit(child)
        elif tag == 'mspace':
            from .mspace_visitor import MspaceVisitor
            return MspaceVisitor(self.strategy).visit(child)
        elif tag == 'menclose':
            from .menclose_visitor import MencloseVisitor
            return MencloseVisitor(self.strategy).visit(child)
        elif tag == 'mmultiscripts':
            from .mmultiscripts_visitor import MmultiscriptsVisitor
            return MmultiscriptsVisitor(self.strategy).visit(child)
        elif tag == 'maction':
            from .maction_visitor import MactionVisitor
            return MactionVisitor(self.strategy).visit(child)
        elif tag == 'merror':
            from .merror_visitor import MerrorVisitor
            return MerrorVisitor(self.strategy).visit(child)
        elif tag == 'mpadded':
            from .mpadded_visitor import MpaddedVisitor
            return MpaddedVisitor(self.strategy).visit(child)
        elif tag == 'mphantom':
            from .mphantom_visitor import MphantomVisitor
            return MphantomVisitor(self.strategy).visit(child)
        elif tag == 'ms':
            from .ms_visitor import MsVisitor
            return MsVisitor(self.strategy).visit(child)
        elif tag == 'mglyph':
            from .mglyph_visitor import MglyphVisitor
            return MglyphVisitor(self.strategy).visit(child)
        elif tag == 'maligngroup':
            from .maligngroup_visitor import MaligngroupVisitor
            return MaligngroupVisitor(self.strategy).visit(child)
        elif tag == 'malignmark':
            from .malignmark_visitor import MalignmarkVisitor
            return MalignmarkVisitor(self.strategy).visit(child)
        elif tag == 'mlabeledtr':
            from .mlabeledtr_visitor import MlabeledtrVisitor
            return MlabeledtrVisitor(self.strategy).visit(child)
        else:
            # Fallback: return text content for unknown elements
            import sys
            print(f"[WARNING] Unknown element <{tag}> in mtd, using text fallback", file=sys.stderr)
            return _text_content(child)

    def can_handle(self, node: ET.Element) -> bool:
        """Check if this visitor can handle the given node."""
        return _local(node.tag) == 'mtd'

    @property
    def element_name(self) -> str:
        """Get the element name this visitor handles."""
        return 'mtd'

    def __repr__(self) -> str:
        """String representation for debugging."""
        return f"MtdVisitor(strategy={self.strategy.name})"