comment_completion

def apply_code_block_backgrounds(text_edit: QTextEdit) -> None:
    """Apply a full-width background colour to every fenced code block.

    ``QSyntaxHighlighter.setFormat()`` only paints behind individual
    text characters, so the end of a short line keeps the regular widget
    background.  Setting ``QTextBlockFormat.background`` instead causes
    Qt's own layout engine to paint the background across the *entire*
    width of the block before any characters are drawn.

    This function is intentionally separate from
    :class:`MentionHighlighter` because Qt's documentation forbids
    modifying the document from inside ``highlightBlock()``.

    Two detection strategies are combined so that code blocks are
    recognised in both scenarios:

    - **Display mode** (after ``document().setMarkdown()``): Qt marks
      fenced code block lines with ``nonBreakableLines=True`` on the
      block format.
    - **Edit mode** (raw typing): Lines inside a ``\\`\\`\\`…\\`\\`\\```` fence
      are detected by tracking an open-fence flag while iterating from
      the first block of the document.

    The function is guarded by the ``_suppress_formatting`` attribute on
    *text_edit* to prevent infinite recursion: writing block formats
    emits ``contentsChanged``, which would otherwise re-enter this
    function.

    Args:
        text_edit: The QTextEdit whose document should have fenced code
            block backgrounds applied.
    """
    if getattr(text_edit, "_suppress_formatting", False):
        return

    doc = text_edit.document()
    setattr(text_edit, "_suppress_formatting", True)

    cursor = QTextCursor(doc)
    cursor.beginEditBlock()

    try:
        in_fence = False
        block = doc.begin()
        while block.isValid():
            text = block.text()
            is_code = False

            # Display mode: Qt-rendered fenced code block.
            if block.blockFormat().nonBreakableLines():
                is_code = True
            else:
                # Edit mode: raw ``` fence markers.
                if in_fence:
                    is_code = True
                    if text.startswith("```"):
                        in_fence = False  # closing fence line — still code
                elif text.startswith("```"):
                    is_code = True
                    rest = text[3:]
                    if "```" not in rest:
                        in_fence = True  # opening fence
                    # else: single-line ```…``` — is_code=True, no state change

            bg_brush = block.blockFormat().background()
            has_code_bg = (
                bg_brush.style() != Qt.BrushStyle.NoBrush
                and bg_brush.color().rgb() == CODE_BG.rgb()
            )

            if is_code and not has_code_bg:
                cursor.setPosition(block.position())
                new_fmt = QTextBlockFormat()
                new_fmt.setBackground(CODE_BG)
                cursor.mergeBlockFormat(new_fmt)
            elif not is_code and has_code_bg:
                # Remove the previously applied code background.
                cursor.setPosition(block.position())
                restored = QTextBlockFormat(block.blockFormat())
                restored.clearBackground()
                cursor.setBlockFormat(restored)

            block = block.next()
    except Exception as e:
        logging.info(f"Error in apply_code_block_backgrounds: {e}")
    finally:
        # Ensure we always end the edit block and reset the flag
        cursor.endEditBlock()
        setattr(text_edit, "_suppress_formatting", False)

def format_comment_on_change(text_edit: QTextEdit) -> None:
    """Ensure a :class:`MentionHighlighter` is installed on *text_edit*.

    Idempotent: safe to call on every ``contentsChanged`` signal.  The
    highlighter is created once and attached to the document.  Subsequent
    calls only call :meth:`MentionHighlighter.update_user_list` when the
    ``_user_list`` reference on *text_edit* has been replaced (e.g. after a
    server refresh), which avoids triggering an unnecessary ``rehighlight``
    — and the infinite-recursion that would follow — on every keystroke.

    Args:
        text_edit: The QTextEdit whose document should have mention
            highlighting applied.
    """
    highlighter: MentionHighlighter | None = getattr(
        text_edit, "_mention_highlighter", None
    )
    user_list = getattr(text_edit, "_user_list", [])

    if highlighter is None:
        highlighter = MentionHighlighter(text_edit.document(), user_list)
        text_edit._mention_highlighter = highlighter  # type: ignore[attr-defined]
    elif highlighter._user_list is not user_list:
        # The list object was replaced (e.g. after a user-list refresh).
        # update_user_list() calls rehighlight() which is safe here because
        # this branch is only reached when _suppress_formatting is False and
        # the list identity has changed — not on every keystroke.
        highlighter.update_user_list(user_list)

def on_completer_activated(
    text_edit: QTextEdit,
    text: str,
) -> None:
    """Handle completer selection.

    Args:
        text_edit: The QTextEdit widget with completer.
        text: The selected completion text (user full name).
    """
    cursor = text_edit.textCursor()
    block = cursor.block()
    text_in_block = block.text()
    pos_in_block = cursor.positionInBlock()

    # Find the '@' position
    at_pos = text_in_block.rfind("@", 0, pos_in_block)
    if at_pos == -1:
        return

    # Replace from '@' to cursor with '@' + full_name
    cursor.setPosition(block.position() + at_pos)
    cursor.setPosition(
        block.position() + pos_in_block,
        QTextCursor.MoveMode.KeepAnchor,
    )
    cursor.insertText(f"@{text}")
    text_edit.setTextCursor(cursor)
    popup = text_edit.completer.popup()
    if popup:
        popup.hide()

def on_completer_key_press(
    text_edit: QTextEdit,
    event,
) -> bool:
    """Handle key press events for completer.

    Args:
        text_edit: The QTextEdit widget with completer.
        event: The key press event.

    Returns:
        True if event was handled, False otherwise.
    """
    if not hasattr(text_edit, "completer"):
        return False

    popup = text_edit.completer.popup()
    if popup and popup.isVisible():
        if event.key() in (Qt.Key.Key_Return, Qt.Key.Key_Enter):
            # Get current completion from the selected index
            current_index = popup.currentIndex()
            if current_index.isValid():
                completion = current_index.data()
                if completion:
                    text_edit.completer.activated.emit(completion)
                    return True
    return False

def on_completer_text_changed(
    text_edit: QTextEdit,
) -> None:
    """Handle text changes to show/hide completer.

    Args:
        text_edit: The QTextEdit widget with completer.
    """
    if not hasattr(text_edit, "completer") or text_edit.isReadOnly():
        return

    cursor = text_edit.textCursor()
    block = cursor.block()
    text = block.text()
    pos_in_block = cursor.positionInBlock()

    # Find the last '@' before cursor
    at_pos = text.rfind("@", 0, pos_in_block)
    if at_pos == -1:
        popup = text_edit.completer.popup()
        if popup:
            popup.hide()
        return

    # Get text after '@'
    prefix = text[at_pos + 1 : pos_in_block]

    # Show completer if '@' is followed by nothing or non-space characters
    if not prefix or (prefix and not prefix[0].isspace()):
        text_edit.completer.setCompletionPrefix(prefix)
        show_completer_popup(text_edit, at_pos)
        # Auto-select if only one item
        popup = text_edit.completer.popup()
        if popup:
            popup_model = popup.model()
            row_count = popup_model.rowCount() if popup_model else 0
            if row_count == 1:
                popup.setCurrentIndex(popup_model.index(0, 0))
    else:
        popup = text_edit.completer.popup()
        if popup:
            popup.hide()

def setup_user_completer(
    text_edit: QTextEdit,
    on_completer_activated,
    on_text_changed,
) -> None:
    """Setup user name completer for a QTextEdit widget.

    Args:
        text_edit: The QTextEdit widget to attach completer to.
        on_completer_activated: Callback for completer activation.
        on_text_changed: Callback for text changes.
    """
    users = getattr(text_edit, "_user_list")
    if not users:
        users = [
            User(
                name="not available",
                short_name="not available",
                full_name="not available",
                email="",
                avatar_url="",
            )
        ]
    model = UserCompleterModel(users, text_edit)
    text_edit.completer = QCompleter(model, text_edit)
    text_edit.completer.setCompletionMode(
        QCompleter.CompletionMode.PopupCompletion
    )
    text_edit.completer.setFilterMode(Qt.MatchFlag.MatchContains)
    text_edit.completer.setMaxVisibleItems(4)
    text_edit.completer.setCaseSensitivity(Qt.CaseSensitivity.CaseInsensitive)
    text_edit.completer.setWidget(text_edit)

    # Set custom delegate
    popup = text_edit.completer.popup()
    if popup:
        delegate = UserCompleterDelegate(popup)
        popup.setItemDelegate(delegate)
        popup.setWindowFlag(Qt.WindowType.NoDropShadowWindowHint, True)

    # Connect completer signals
    text_edit.completer.activated.connect(on_completer_activated)
    text_edit.textChanged.connect(on_text_changed)

def show_completer_popup(text_edit: QTextEdit, at_pos: int) -> None:
    """Show completer popup above the QTextEdit.

    Args:
        text_edit: The QTextEdit widget with completer.
        at_pos: Position of '@' character in the block.
    """
    popup = text_edit.completer.popup()
    if not popup:
        return

    # Get editor dimensions
    editor_rect = text_edit.rect()
    editor_width = editor_rect.width()

    # Show popup to get its height
    popup.show()

    # Calculate height based on max visible items (4)
    max_visible = text_edit.completer.maxVisibleItems()
    item_height = popup.sizeHintForRow(0)
    popup_height = item_height * max_visible

    # Position popup above the QTextEdit with same width as editor
    global_pos = text_edit.mapToGlobal(editor_rect.topLeft())
    popup_x = global_pos.x()
    popup_y = global_pos.y() - popup_height

    popup.setGeometry(popup_x, popup_y, editor_width, popup_height)