drawers

class ButtonDrawer:
    def __init__(self, style_inst: AYONStyle) -> None:
        self.style_inst = style_inst
        self.model = style_inst.model

    @property
    def _super(self):
        """Return proxy for calling QCommonStyle methods on style_inst."""
        from ..style import AYONStyle as _AYONStyle

        return super(_AYONStyle, self.style_inst)

    @property
    def base_class(self):
        return {"QPushButton": QPushButton}

    def register_drawers(self):
        return {
            enum_to_str(
                QStyle.ControlElement,
                QStyle.ControlElement.CE_PushButton,
                "QPushButton",
            ): [
                partial(
                    self.style_inst.drawControl,
                    QStyle.ControlElement.CE_PushButtonBevel,
                ),
                partial(
                    self.style_inst.drawControl,
                    QStyle.ControlElement.CE_PushButtonLabel,
                ),
            ],
            enum_to_str(
                QStyle.ControlElement,
                QStyle.ControlElement.CE_PushButtonBevel,
                "QPushButton",
            ): self.draw_push_button_bevel,
            enum_to_str(
                QStyle.ControlElement,
                QStyle.ControlElement.CE_PushButtonLabel,
                "QPushButton",
            ): self.draw_push_button_label,
        }

    def register_sizers(self):
        return {
            enum_to_str(
                QStyle.ContentsType,
                QStyle.ContentsType.CT_PushButton,
                "QPushButton",
            ): self.calculate_push_button_size,
            enum_to_str(
                QStyle.SubElement,
                QStyle.SubElement.SE_PushButtonContents,
                "QPushButton",
            ): self.sub_element_rect,
            enum_to_str(
                QStyle.SubElement,
                QStyle.SubElement.SE_PushButtonFocusRect,
                "QPushButton",
            ): self.sub_element_rect,
        }

    def register_metrics(self):
        return {
            enum_to_str(
                QStyle.PixelMetric,
                QStyle.PixelMetric.PM_ButtonMargin,
                "QPushButton",
            ): self.get_metric,
            enum_to_str(
                QStyle.PixelMetric,
                QStyle.PixelMetric.PM_DefaultFrameWidth,
                "QPushButton",
            ): self.get_metric,
            enum_to_str(
                QStyle.PixelMetric,
                QStyle.PixelMetric.PM_ButtonDefaultIndicator,
                "QPushButton",
            ): self.get_metric,
            enum_to_str(
                QStyle.PixelMetric,
                QStyle.PixelMetric.PM_FocusFrameVMargin,
                "QPushButton",
            ): self.get_metric,
            enum_to_str(
                QStyle.PixelMetric,
                QStyle.PixelMetric.PM_FocusFrameHMargin,
                "QPushButton",
            ): self.get_metric,
        }

    def get_metric(
        self,
        metric: QStyle.PixelMetric,
        opt: QStyleOption | None = None,
        widget: QWidget | None = None,
    ):
        if metric == QStyle.PixelMetric.PM_ButtonMargin:
            return 6
        elif metric == QStyle.PixelMetric.PM_DefaultFrameWidth:
            return 0
        elif metric == QStyle.PixelMetric.PM_ButtonDefaultIndicator:
            return 0
        elif metric == QStyle.PixelMetric.PM_FocusFrameVMargin:
            return 2
        elif metric == QStyle.PixelMetric.PM_FocusFrameHMargin:
            return 2

    def get_button_variant(self, widget: QWidget) -> str:
        """Extract button variant from widget properties."""
        if widget is None:
            return "surface"
        return getattr(widget, "_variant_str", "surface")

    def get_button_has_icon(self, widget: QWidget) -> bool:
        """Check if button has an icon."""
        if widget is None:
            return False

        # Method 1: Try has_icon property
        if hasattr(widget, "has_icon"):
            return widget.has_icon  # type: ignore

        # Method 2: Try Qt property
        has_icon_prop = widget.property("has_icon")
        if has_icon_prop is not None:
            return bool(has_icon_prop)

        # Method 3: Check the actual icon
        return bool(widget.icon() and not widget.icon().isNull())  # type: ignore

    def get_button_style(
        self, widget: QWidget, state: QStyle.StateFlag
    ) -> tuple[dict, str]:
        """Get the appropriate style dictionary for the widget's variant and
        state."""
        variant = self.get_button_variant(widget)

        is_hover = bool(
            state & QStyle.StateFlag.State_MouseOver
        ) or widget.underMouse()

        wstate = "base"
        if not (state & QStyle.StateFlag.State_Enabled):
            wstate = "disabled"
        elif state & QStyle.StateFlag.State_Sunken:
            wstate = "pressed"
        elif is_hover and state & QStyle.StateFlag.State_On:
            # A checked button hovered stays on its checked colour, just
            # brighter. Falling back to the plain "hover" grey - which
            # this did unless a variant spelled out "checked-hover" -
            # dropped the only cue that the button is the active one.
            # A variant that defines no "checked-hover" resolves to
            # "checked", so the colour holds rather than turning grey.
            wstate = "checked-hover"
        elif is_hover:
            wstate = "hover"
        elif state & QStyle.StateFlag.State_On:
            wstate = "checked"

        style = self.model.get_style("QPushButton", variant, wstate)
        style.set_context(widget)

        return style, wstate

    def draw_push_button_bevel(
        self,
        option: QStyleOption,
        painter: QPainter,
        widget: QWidget | None,
    ) -> None:
        """Draw the button background and frame with hover detection."""
        option = _get_button_option(option, widget)
        if option is None or widget is None:
            return

        style, _ = self.get_button_style(widget, option.state)
        rect = option.rect

        painter.save()
        painter.setRenderHint(QPainter.RenderHint.Antialiasing)

        # Draw button background with hover awareness
        # NOTE: QColor(...) wrapping is required here - PySide2's QBrush
        # constructor (unlike PySide6's) does not implicitly convert a
        # plain hex-color string, silently producing an invisible
        # NoBrush instead.
        bg_color = QColor(style["background-color"])
        painter.setOpacity(style.get("opacity", 1.0))

        painter.setBrush(QBrush(bg_color))
        painter.setPen(Qt.PenStyle.NoPen)
        border_radius = style.get("border-radius", 0)

        draw_icon_as_background = style.get("icon-as-background", False)
        clip_icon_to_radius = style.get("clip-icon-to-radius", False)

        if draw_icon_as_background:
            # draw the icon clipped by the same rounded rect
            painter.save()
            if clip_icon_to_radius:
                clip_path = QPainterPath()
                clip_path.addRoundedRect(rect, border_radius, border_radius)
                painter.setClipPath(clip_path)

            mode = QtGui.QIcon.Mode.Normal
            painter.drawRoundedRect(rect, border_radius, border_radius)
            option.icon.paint(
                painter,
                rect,
                Qt.AlignmentFlag.AlignCenter,
                mode,
            )

            if clip_icon_to_radius:
                painter.setClipping(False)

            pen = QPen(QColor(style.get("border-color")))
            pen.setWidth(int(style.get("border-width", 0)))
            painter.setPen(pen)
            painter.setBrush(Qt.BrushStyle.NoBrush)
            painter.drawRoundedRect(rect, border_radius, border_radius)
            painter.restore()
        else:
            painter.drawRoundedRect(rect, border_radius, border_radius)

        # Draw focus outline if needed
        if (
            option.state & QStyle.StateFlag.State_HasFocus
            and option.state  # type: ignore
            & QStyle.StateFlag.State_KeyboardFocusChange
        ):
            focus_color = style["focus-outline-color"]
            pen = QPen(
                QColor(focus_color), style.get("focus-outline-width", 0)
            )
            painter.setPen(pen)
            painter.setBrush(Qt.BrushStyle.NoBrush)
            focus_rect = rect.adjusted(1, 1, -1, -1)
            painter.drawRoundedRect(
                focus_rect, border_radius + 1, border_radius + 1
            )

        painter.restore()

    def draw_push_button_label(
        self,
        option: QStyleOption,
        painter: QPainter,
        widget: QWidget | None,
    ) -> None:
        """Draw the button text and icon."""
        option = _get_button_option(option, widget)
        if option is None or widget is None:
            return

        style, wstate = self.get_button_style(widget, option.state)  # type: ignore
        variant = self.get_button_variant(widget)

        # Set up text color
        text_color = self.model.get_widget_color(
            "color",
            style,
            widget,
            widget.palette().color(QPalette.ColorRole.ButtonText),
        )
        if not (option.state & QStyle.StateFlag.State_Enabled):  # type: ignore
            # Apply some opacity to disabled text
            text_color.setAlpha(int(255 * 0.5))

        painter.save()
        painter.setPen(text_color)

        # Set up font
        painter.setFont(widget.font())

        # Get content rectangle
        content_rect = self.style_inst.subElementRect(
            QStyle.SubElement.SE_PushButtonContents, option, widget
        )

        # Optional per-widget alignment override (None → default centered
        # layout)
        label_alignment = getattr(widget, "_label_alignment", None)

        if not option.icon:  # type: ignore
            # Text only
            if option.text and not style.get("ignore-text", False):  # type: ignore
                _text_align = (
                    (label_alignment & Qt.AlignmentFlag.AlignHorizontal_Mask)
                    | Qt.AlignmentFlag.AlignVCenter
                    if label_alignment is not None
                    else Qt.AlignmentFlag.AlignCenter
                )
                painter.drawText(
                    content_rect,
                    _text_align,
                    option.text,  # type: ignore
                )
            painter.restore()
            return

        # Draw icon if present
        if option.text and not style.get("ignore-text", False):  # type: ignore
            icon_size = option.iconSize  # type: ignore
            icon_w = icon_size.width()
            icon_h = icon_size.height()
            _gap = 4

            # Draw icon with text color inheritance
            mode = QtGui.QIcon.Mode.Normal
            if not (
                option.state & QStyle.StateFlag.State_Enabled  # type: ignore
            ):
                mode = QtGui.QIcon.Mode.Disabled
            elif option.state & QStyle.StateFlag.State_Sunken:  # type: ignore
                mode = QtGui.QIcon.Mode.Active

            # Same On/Off-as-hover encoding the icon-only branch below
            # uses: AYButton.set_icon() bakes the hover color into the
            # icon's "On" state for non-checkable buttons. Without
            # selecting that state here, an icon+text button's icon
            # never picks up its hover color even though the text does.
            checkable = widget.isCheckable() if widget else False
            icon_state = (
                (
                    QtGui.QIcon.State.On
                    if wstate == "hover"
                    else QtGui.QIcon.State.Off
                )
                if not checkable
                else (
                    QtGui.QIcon.State.On
                    if option.state & QStyle.StateFlag.State_On  # type: ignore
                    else QtGui.QIcon.State.Off
                )
            )

            if label_alignment is not None:
                # Group layout: icon + text move together as a unit
                h_align = (
                    label_alignment & Qt.AlignmentFlag.AlignHorizontal_Mask
                )
                text_w = painter.fontMetrics().horizontalAdvance(
                    option.text  # type: ignore
                )
                group_w = icon_w + _gap + text_w
                if h_align == Qt.AlignmentFlag.AlignLeft:
                    group_x = content_rect.left()
                elif h_align == Qt.AlignmentFlag.AlignRight:
                    group_x = content_rect.right() - group_w
                else:
                    group_x = (
                        content_rect.left()
                        + (content_rect.width() - group_w) // 2
                    )
                icon_rect = QRect(
                    group_x,
                    content_rect.center().y() - icon_h // 2,
                    icon_w,
                    icon_h,
                )
                text_rect = QRect(
                    icon_rect.right() + _gap,
                    content_rect.top(),
                    text_w,
                    content_rect.height(),
                )
                option.icon.paint(  # type: ignore
                    painter,
                    icon_rect,
                    Qt.AlignmentFlag.AlignCenter,
                    mode,
                    icon_state,
                )
                painter.drawText(
                    text_rect,
                    Qt.AlignmentFlag.AlignLeft
                    | Qt.AlignmentFlag.AlignVCenter,
                    option.text,  # type: ignore
                )
            else:
                # Icon + text: place icon on the left (default centered)
                icon_rect = QRect(content_rect)
                icon_rect.setSize(icon_size)
                icon_rect.moveCenter(
                    QtCore.QPoint(
                        content_rect.left() + style["icon-padding"][0],
                        content_rect.center().y(),
                    )
                )
                option.icon.paint(  # type: ignore
                    painter,
                    icon_rect,
                    Qt.AlignmentFlag.AlignCenter,
                    mode,
                    icon_state,
                )
                # Adjust text rectangle
                text_rect = QRect(content_rect)
                text_rect.setLeft(icon_rect.right() + _gap)
                # Draw text
                painter.drawText(
                    text_rect,
                    Qt.AlignmentFlag.AlignLeft
                    | Qt.AlignmentFlag.AlignVCenter,
                    option.text,  # type: ignore
                )
        elif variant not in ("thumbnail", "entity-card"):
            # Icon only
            mode = QtGui.QIcon.Mode.Normal
            if not (
                option.state & QStyle.StateFlag.State_Enabled  # type: ignore
            ):
                mode = QtGui.QIcon.Mode.Disabled
            elif option.state & QStyle.StateFlag.State_Sunken:  # type: ignore
                mode = QtGui.QIcon.Mode.Active

            checkable = widget.isCheckable() if widget else False

            icon_state = (
                (
                    QtGui.QIcon.State.On
                    if wstate == "hover"
                    else QtGui.QIcon.State.Off
                )
                if not checkable
                else (
                    QtGui.QIcon.State.On
                    if option.state & QStyle.StateFlag.State_On
                    else QtGui.QIcon.State.Off
                )
            )

            _icon_align = (
                (label_alignment & Qt.AlignmentFlag.AlignHorizontal_Mask)
                | Qt.AlignmentFlag.AlignVCenter
                if label_alignment is not None
                else Qt.AlignmentFlag.AlignCenter
            )
            option.icon.paint(  # type: ignore
                painter,
                content_rect,
                _icon_align,
                mode,
                icon_state,
            )

        painter.restore()

    def calculate_push_button_size(
        self,
        contents_type: QStyle.ContentsType,
        option: QStyleOption | None,
        contents_size: QtCore.QSize,
        widget: QWidget | None,
    ) -> QtCore.QSize:
        """Calculate minimum size for push buttons with text, icons,
        and proper padding."""

        button_option = _get_button_option(option, widget)
        if button_option is None:
            # Fallback to parent if we don't have proper option data
            if option is not None:
                return self._super.sizeFromContents(
                    contents_type,
                    option,
                    contents_size,
                    widget,
                )
            else:
                # Return reasonable default for button if no option
                return QtCore.QSize(100, 30)
        option = button_option

        # Set up font for text measurement
        style, _ = self.get_button_style(widget, option.state)  # type: ignore
        font = widget.font() if widget else style_font(style, widget)

        # Create font metrics for accurate text measurement
        font_metrics = QFontMetrics(font)

        # Determine if button has icon
        has_icon = (
            self.get_button_has_icon(widget)
            if widget
            else not option.icon.isNull()  # type: ignore
        )
        has_icon = not option.icon.isNull()

        # Determine appropriate padding
        if has_icon and not option.text:  # type: ignore
            # Icon-only button
            padding = style["icon-padding"]
        else:
            # Text button or icon+text button
            padding = style["text-padding"]

        # Calculate text dimensions
        text_width = 0
        text_height = 0
        if option.text and not style.get("ignore-text", False):  # type: ignore
            text_rect = font_metrics.boundingRect(option.text)  # type: ignore
            text_width = text_rect.width()
            text_height = text_rect.height()

        # Calculate icon dimensions
        icon_width = 0
        icon_height = 0
        if has_icon:
            icon_size = option.iconSize  # type: ignore
            icon_width = icon_size.width()
            icon_height = icon_size.height()

        # Calculate content dimensions
        content_width = 0
        content_height = 0

        if has_icon and option.text:  # type: ignore
            # Icon + text: icon on left, 4px spacing, then text
            content_width = icon_width + 4 + text_width
            content_height = max(icon_height, text_height)
        elif has_icon:
            # Icon only
            content_width = icon_width
            content_height = icon_height
        elif option.text:  # type: ignore
            # Text only
            content_width = text_width
            content_height = text_height

        # Add padding (vertical, horizontal)
        total_width = content_width + (
            2 * padding[1]
        )  # horizontal padding on both sides
        total_height = content_height + (
            2 * padding[0]
        )  # vertical padding on top and bottom

        # Ensure minimum button size (reasonable minimums)
        min_width = 16
        min_height = 16

        total_width = max(total_width, min_width)
        total_height = max(total_height, min_height)

        return QtCore.QSize(total_width, total_height)

    def sub_element_rect(
        self,
        element: QStyle.SubElement,
        option: QStyleOption,
        widget: QWidget,
    ):
        button_option = _get_button_option(option, widget)
        if button_option is None:
            raise ValueError("Button option could not be initialized")
        option = button_option
        if element == QStyle.SubElement.SE_PushButtonContents:
            style = self.model.get_style(
                "QPushButton", self.get_button_variant(widget)
            )
            style.set_context(widget)
            if option.icon:
                padding = (
                    style["icon-padding"]
                    if not widget.text()  # type: ignore
                    else style["text-padding"]
                )
            else:
                padding = style["text-padding"]

            return option.rect.adjusted(  # type: ignore
                padding[1], padding[0], -padding[1], -padding[0]
            )

        elif element == QStyle.SubElement.SE_PushButtonFocusRect:
            return option.rect.adjusted(-2, -2, 2, 2)  # type: ignore

        raise ValueError(f"Nothing returned ! -> {element}")

class CheckboxDrawer:
    def __init__(self, style_inst: AYONStyle) -> None:
        self.style_inst = style_inst
        self.model = style_inst.model

    @property
    def _super(self):
        """Return proxy for calling QCommonStyle methods on style_inst."""
        from ..style import AYONStyle as _AYONStyle

        return super(_AYONStyle, self.style_inst)

    @property
    def base_class(self):
        return {"QCheckBox": QCheckBox}

    def register_drawers(self):
        return {
            enum_to_str(
                QStyle.ControlElement,
                QStyle.ControlElement.CE_CheckBox,
                "QCheckBox",
            ): self.draw_indicator,
            enum_to_str(
                QStyle.PrimitiveElement,
                QStyle.PrimitiveElement.PE_IndicatorCheckBox,
                "QCheckBox",
            ): self.draw_toggle,
            enum_to_str(
                QStyle.PrimitiveElement,
                QStyle.PrimitiveElement.PE_FrameFocusRect,
                "QCheckBox",
            ): do_nothing,
        }

    def register_metrics(self):
        return {
            enum_to_str(
                QStyle.PixelMetric,
                QStyle.PixelMetric.PM_IndicatorWidth,
                "QCheckBox",
            ): self.get_metric,
            enum_to_str(
                QStyle.PixelMetric,
                QStyle.PixelMetric.PM_IndicatorHeight,
                "QCheckBox",
            ): self.get_metric,
            enum_to_str(
                QStyle.PixelMetric,
                QStyle.PixelMetric.PM_CheckBoxLabelSpacing,
                "QCheckBox",
            ): self.get_metric,
        }

    def get_metric(
        self,
        metric: QStyle.PixelMetric,
        opt: QStyleOption | None = None,
        widget: QWidget | None = None,
    ):
        variant = getattr(widget, "_variant_str", "default")
        style = self.model.get_style(
            "QCheckBox",
            variant=variant,
        )
        style.set_context(widget)
        metrics_h = widget.fontMetrics().height() if widget else 18
        metrics_w = metrics_h * 2 if widget else 32

        if metric == QStyle.PixelMetric.PM_IndicatorWidth:
            # if indicator-width == 0, use 2x the font height.
            return style.get("indicator-width", metrics_w) or metrics_w
        elif metric == QStyle.PixelMetric.PM_IndicatorHeight:
            # if indicator-height == 0, use the font height.
            return style.get("indicator-height", metrics_h) or metrics_h
        elif metric == QStyle.PixelMetric.PM_CheckBoxLabelSpacing:
            return style.get("checkbox-label-spacing", 8)
        return 0

    def draw_indicator(
        self,
        option: QStyleOption,
        painter: QPainter,
        widget: QWidget | None,
    ):
        variant = getattr(widget, "_variant_str", "default")
        state = (
            "checked" if option.state & QStyle.StateFlag.State_On else "base"
        )
        style = self.model.get_style(
            "QCheckBox",
            variant=variant,
            state=state,
        )
        style.set_context(widget)

        if style.get("background-color"):
            painter.save()
            painter.setBrush(QColor(style["background-color"]))
            painter.setPen(Qt.PenStyle.NoPen)
            radius = style.get("border-radius", 0)
            painter.drawRoundedRect(option.rect, radius, radius)
            painter.restore()

        if style.get("indicator-position", "left") == "right":
            # Manually draw a centred [label  toggle] group so that padding
            # is equal on both sides, instead of relying on Qt's layout.
            s = self.style_inst
            ind_w = s.pixelMetric(
                QStyle.PixelMetric.PM_IndicatorWidth, option, widget
            )
            ind_h = s.pixelMetric(
                QStyle.PixelMetric.PM_IndicatorHeight, option, widget
            )
            spacing = s.pixelMetric(
                QStyle.PixelMetric.PM_CheckBoxLabelSpacing, option, widget
            )

            text = getattr(option, "text", "")
            fm = option.fontMetrics
            text_w = fm.horizontalAdvance(text) if text else 0
            text_h = fm.height()

            total_w = text_w + (spacing + ind_w if text_w else ind_w)

            rect = option.rect
            cx = rect.center().x()
            cy = rect.center().y()
            x = cx - total_w // 2

            painter.save()
            if text:
                painter.setPen(
                    QColor(style["color"])
                    if style.get("color")
                    else option.palette.color(QPalette.ColorRole.WindowText)
                )
                text_rect = QRect(x, cy - text_h // 2, text_w, text_h)
                painter.drawText(
                    text_rect,
                    Qt.AlignmentFlag.AlignVCenter | Qt.AlignmentFlag.AlignLeft,
                    text,
                )

            toggle_opt = QStyleOption(option)
            toggle_opt.rect = QRect(
                x + text_w + (spacing if text_w else 0),
                cy - ind_h // 2,
                ind_w,
                ind_h,
            )
            self.draw_toggle(toggle_opt, painter, widget)
            painter.restore()
            return

        if style.get("color"):
            option.palette.setColor(
                QPalette.ColorRole.WindowText, QColor(style["color"])
            )

        self._super.drawControl(
            QStyle.ControlElement.CE_CheckBox, option, painter, widget
        )

    def draw_toggle(
        self,
        option: QStyleOption,
        painter: QPainter,
        w: QWidget | None = None,
    ):
        painter.save()
        painter.setRenderHint(QPainter.RenderHint.Antialiasing, True)

        # get style data
        checked = bool(option.state & QStyle.StateFlag.State_On)
        variant = getattr(w, "_variant_str", "default")
        styles = {}
        for state in ("base", "checked"):
            styles[state] = self.model.get_style(
                "QCheckBox", variant=variant, state=state
            )
            styles[state].set_context(w)
        style = styles["checked" if checked else "base"]

        # 0.0 is unchecked, 1.0 is checked; animated by the widget if it
        # supports it.
        progress = getattr(w, "_toggle_progress", 1.0 if checked else 0.0)

        def _color(key: str) -> QColor:
            base = styles["base"].get(key) or styles["checked"][key]
            checked_ = styles["checked"].get(key) or base
            return self._mix(QColor(base), QColor(checked_), progress)

        # draw toggle background
        painter.setBrush(_color("indicator-background-color"))
        if style.get("indicator-border-width", 0):
            pen = QPen(_color("indicator-border-color"))
            pen.setWidth(style.get("indicator-border-width", 0))
            painter.setPen(pen)
        else:
            painter.setPen(Qt.PenStyle.NoPen)
        frame_rect: QRectF = QRectF(option.rect).adjusted(1, 0, -1, 0)
        radius = frame_rect.height() / 2.0
        painter.drawRoundedRect(frame_rect, radius, radius)

        # draw toggle knob
        painter.setBrush(_color("indicator-color"))
        offset = frame_rect.height() * 0.125
        state_rect: QRectF = frame_rect.adjusted(
            offset, offset, -offset, -offset
        )
        state_rect.setWidth(state_rect.height())
        travel = frame_rect.width() - 2 * offset - state_rect.width()
        state_rect.moveLeft(state_rect.left() + travel * progress)
        painter.drawEllipse(state_rect)

        painter.restore()

    @staticmethod
    def _mix(color_a: QColor, color_b: QColor, ratio: float) -> QColor:
        """Linearly interpolate two colors (including alpha)."""
        if ratio <= 0.0:
            return color_a
        if ratio >= 1.0:
            return color_b
        return QColor.fromRgbF(
            *(
                a + (b - a) * ratio
                for a, b in zip(
                    color_a.getRgbF(), color_b.getRgbF()
                )
            )
        )

class ComboBoxDrawer:
    def __init__(self, style_inst: AYONStyle) -> None:
        self.style_inst = style_inst
        self.model = style_inst.model

    @property
    def _super(self):
        """Return proxy for calling QCommonStyle methods on style_inst."""
        from ..style import AYONStyle as _AYONStyle

        return super(_AYONStyle, self.style_inst)

    @property
    def base_class(self):
        return {"QComboBox": QComboBox}

    def register_drawers(self):
        return {
            enum_to_str(
                QStyle.ControlElement,
                QStyle.ControlElement.CE_ComboBoxLabel,
                "QComboBox",
            ): self.draw_label,
            enum_to_str(
                QStyle.ComplexControl,
                QStyle.ComplexControl.CC_ComboBox,
                "QComboBox",
            ): self.draw_box,
            enum_to_str(
                QStyle.PrimitiveElement,
                QStyle.PrimitiveElement.PE_PanelItemViewItem,
                "QFrame",
            ): self.draw_panel_item_view_item,
            enum_to_str(
                QStyle.PrimitiveElement,
                QStyle.PrimitiveElement.PE_FrameFocusRect,
                "QFrame",
            ): do_nothing,
        }

    def register_sizers(self):
        return {
            enum_to_str(
                QStyle.ContentsType,
                QStyle.ContentsType.CT_ComboBox,
                "QComboBox",
            ): self.combobox_size,
        }

    def get_fg_bg_colors(
        self,
        opt: QtWidgets.QStyleOptionComplex,
        w: QComboBox,
    ) -> tuple[QColor, QColor]:
        bg_color = opt.palette.color(
            QPalette.ColorGroup.Active, QPalette.ColorRole.Base
        )
        fg_color = opt.palette.color(
            QPalette.ColorGroup.Active, QPalette.ColorRole.ButtonText
        )

        inverted = getattr(w, "_inverted", False)
        current_index = w.currentIndex()
        if current_index >= 0:
            item_color = w.itemData(
                current_index, QtCore.Qt.ItemDataRole.ForegroundRole
            )
            if item_color is not None:
                item_color = item_color.color()
                fg_color = bg_color if inverted else item_color
                bg_color = item_color if inverted else bg_color

        return fg_color, bg_color

    def draw_box(
        self,
        opt: QtWidgets.QStyleOptionComplex,
        p: QPainter,
        w: QComboBox | None = None,
    ):
        if not isinstance(w, QComboBox):
            return

        state = (
            "hover"
            if (
                opt.state & QStyle.StateFlag.State_MouseOver
                or w.underMouse()
            )
            else "base"
        )
        _style = self.model.get_style(
            "QComboBox",
            variant=getattr(w, "_variant_str", None),
            state=state,
        )
        _style.set_context(w)
        style_bg_color = _style.get("background-color", None)
        opt.palette.setBrush(
            QPalette.ColorRole.Base,
            QColor(style_bg_color)
            if style_bg_color
            else self.model.base_palette.base(),
        )
        _radius = _style.get("border-radius", 0)

        if not w.isEditable():
            fg_color, bg_color = self.get_fg_bg_colors(opt, w)

            # Paint background with status color
            rect = opt.rect
            p.save()
            p.setBrush(QBrush(bg_color))
            p.setPen(QtCore.Qt.PenStyle.NoPen)
            p.drawRoundedRect(rect, _radius, _radius)
            p.restore()

            # Draw expand_more arrow if show_chevron is True
            show_chevron = getattr(w, "show_chevron", True)
            if show_chevron:
                arrow_rect = self._super.subControlRect(
                    QStyle.ComplexControl.CC_ComboBox,
                    opt,
                    QStyle.SubControl.SC_ComboBoxArrow,
                    w,
                )
                arrow_icon = get_icon("expand_more", fg_color)
                if arrow_icon and not arrow_rect.isEmpty():
                    arrow_size = min(arrow_rect.width(), arrow_rect.height())
                    pixmap = arrow_icon.pixmap(arrow_size, arrow_size)
                    popup_open = bool(opt.state & QStyle.StateFlag.State_On)
                    if popup_open:
                        pixmap = pixmap.transformed(QTransform().rotate(180))

                    px = (
                        arrow_rect.x()
                        + (arrow_rect.width() - arrow_size) // 2
                    )
                    py = (
                        arrow_rect.y()
                        + (arrow_rect.height() - arrow_size) // 2
                    )

                    p.drawPixmap(px, py, pixmap)

            # set pen for text drawing
            p.setPen(fg_color)
        else:
            # editable combobox - IMPLEMENT ME
            self._super.drawComplexControl(
                QStyle.ComplexControl.CC_ComboBox, opt, p, w
            )

    def draw_label(
        self,
        opt: QStyleOptionComboBox,
        p: QPainter,
        w: QWidget,
    ):
        if not isinstance(w, QComboBox):
            return

        _style = self.model.get_style(
            "QComboBox", variant=getattr(w, "_variant_str", None)
        )
        _style.set_context(w)
        icon_padding = _style.get("icon-padding", [4, 4])
        text_padding = _style.get("text-padding", [1, 1])

        fg_color, bg_color = self.get_fg_bg_colors(opt, w)

        base_cls = self._super
        edit_rect = base_cls.subControlRect(
            QStyle.ComplexControl.CC_ComboBox,
            opt,
            QStyle.SubControl.SC_ComboBoxEditField,
            w,
        )
        p.save()
        p.setClipRect(edit_rect)
        if opt.currentIcon:
            mode = (
                QIcon.Mode.Normal
                if opt.state & QStyle.StateFlag.State_Enabled
                else QIcon.Mode.Disabled
            )
            pixmap = opt.currentIcon.pixmap(opt.iconSize, mode)
            icon_rect = QRect(edit_rect)
            icon_rect.setWidth(opt.iconSize.width() + icon_padding[0])
            icon_rect.setHeight(opt.iconSize.height() + icon_padding[1])
            icon_rect = QStyle.alignedRect(
                opt.direction,
                Qt.AlignmentFlag.AlignLeft | Qt.AlignmentFlag.AlignVCenter,
                icon_rect.size(),
                edit_rect,
            )
            if opt.editable:
                p.fillRect(
                    icon_rect, opt.palette.brush(QPalette.ColorRole.Base)
                )
            base_cls.drawItemPixmap(
                p, icon_rect, Qt.AlignmentFlag.AlignCenter, pixmap
            )
            if opt.direction == Qt.LayoutDirection.RightToLeft:
                edit_rect.translate(-icon_padding[0] - opt.iconSize.width(), 0)
            else:
                edit_rect.translate(opt.iconSize.width() + icon_padding[0], 0)

        if opt.currentText and not opt.editable:
            base_cls.drawItemText(
                p,
                edit_rect.adjusted(
                    text_padding[0],
                    -text_padding[1],
                    -text_padding[0],
                    text_padding[1],
                ),
                QStyle.visualAlignment(
                    opt.direction,
                    Qt.AlignmentFlag.AlignLeft | Qt.AlignmentFlag.AlignVCenter,
                ),
                opt.palette,
                bool(opt.state & QStyle.StateFlag.State_Enabled),
                opt.currentText,
            )

        p.restore()

    def draw_panel_item_view_item(
        self, option: QStyleOption, painter: QPainter, w: QWidget
    ):
        cb = w.model().parent()
        if cb and getattr(cb, "_inverted", False):
            idx = option.index
            if idx:
                fgc = (
                    w.model().data(idx, Qt.ItemDataRole.ForegroundRole).color()
                )
                option.backgroundBrush.setColor(fgc)
        else:
            stl = self.model.get_style("QComboBox")
            stl.set_context(w)
            option.backgroundBrush.setColor(
                QColor(stl["menu-background-color"])
            )
        self._super.drawPrimitive(  # type: ignore
            QStyle.PrimitiveElement.PE_PanelItemViewItem, option, painter, w
        )

    def combobox_size(
        self,
        contents_type: QStyle.ContentsType,
        option: QStyleOption | None,
        contents_size: QtCore.QSize,
        widget: QWidget | None,
    ) -> QtCore.QSize:
        from qtpy.QtCore import QSize

        if not option or not isinstance(option, QStyleOptionComboBox):
            return QSize()

        style = self.model.get_style("QComboBox")
        style.set_context(widget)

        text_width = cb_height = 0
        if isinstance(widget, QComboBox):
            for i in range(widget.count()):
                t_rect = option.fontMetrics.boundingRect(
                    widget.itemData(i, Qt.ItemDataRole.DisplayRole)
                )
                text_width = max(text_width, t_rect.width())
                cb_height = max(cb_height, t_rect.height())

        text_width += style["text-padding"][0] * 2
        cb_height += style["text-padding"][1] * 2

        icon_width = 0
        if option.currentIcon:
            icon_size = getattr(widget, "_icon_size", 0)
            if icon_size == 0:
                all_sizes = option.currentIcon.availableSizes()
                icon_size = max(all_sizes[0].width(), all_sizes[0].height())
            icon_width = icon_size + style["icon-padding"][0] * 2
            icon_height = icon_size + style["icon-padding"][1] * 2
            cb_height = max(cb_height, icon_height)
            if text_width:
                icon_width += style["text-padding"][0]

        final_size = QSize(
            text_width + icon_width,
            min(getattr(widget, "_height", cb_height), cb_height),
        )
        return final_size