r"""
Visitor for <mpadded> (padded content) MathML elements.

The <mpadded> element is used to adjust the spacing and positioning of its content
by adding padding. It supports attributes like width, height, depth, lwidth, and voffset.

In LaTeX conversion, mpadded is typically treated as a transparent wrapper since
LaTeX doesn't have a direct equivalent for fine-grained spacing control. The padding
attributes are generally ignored, and only the content is converted.

This visitor acts as a transparent container, similar to <mrow>.
"""

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


class MpaddedVisitor(Visitor):
    r"""
    Handles <mpadded> (padded content) MathML elements.

    Acts as a transparent wrapper, converting only the content without
    applying padding attributes (LaTeX doesn't have direct equivalents).

    Examples:
        Simple padding (transparent):
            <mpadded width="+1em"><mi>x</mi></mpadded>
            → x

        Padded expression:
            <mpadded lspace="0.5em"><mrow><mi>a</mi><mo>+</mo><mi>b</mi></mrow></mpadded>
            → a+b

        Padded fraction:
            <mpadded height="+1em"><mfrac><mi>a</mi><mi>b</mi></mfrac></mpadded>
            → \frac{a}{b}

        Empty padding:
            <mpadded width="0em"><mi>x</mi></mpadded>
            → x

    Note:
        MathML padding attributes (width, height, depth, lwidth, voffset) are
        intentionally ignored in LaTeX conversion as there's no direct equivalent.
        For precise spacing control in LaTeX, use \hspace{}, \vspace{}, or \phantom{}.
    """

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

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

        Padding attributes are ignored in conversion.

        Args:
            node: The <mpadded> element to convert

        Returns:
            LaTeX string with content only (no padding applied)

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

        # Simply convert children, ignoring padding attributes
        return self._convert_children(node)

    def _convert_children(self, node: ET.Element) -> str:
        """
        Convert all child elements to LaTeX.

        Args:
            node: The <mpadded> element

        Returns:
            LaTeX string with all children converted
        """
        parts = []
        for child in node:
            parts.append(self._convert_child(child))
        return ''.join(parts)

    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 mpadded, 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) == 'mpadded'

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

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